PyQLop0.cpp
10781 lines
| 393.2 KiB
| text/x-c
|
CppLexer
r5 | #include "PyQLop0.h" | |||
#include <PythonQtConversion.h> | ||||
#include <PythonQtMethodInfo.h> | ||||
#include <PythonQtSignalReceiver.h> | ||||
#include <QVariant> | ||||
r6 | #include <qabstractitemmodel.h> | |||
r5 | #include <qaction.h> | |||
#include <qbackingstore.h> | ||||
#include <qbitmap.h> | ||||
r6 | #include <qbrush.h> | |||
r5 | #include <qbytearray.h> | |||
r6 | #include <qcolor.h> | |||
r5 | #include <qcoreevent.h> | |||
#include <qcursor.h> | ||||
r6 | #include <qcustomplot.h> | |||
r5 | #include <qdockwidget.h> | |||
#include <qevent.h> | ||||
#include <qfont.h> | ||||
r6 | #include <qfontinfo.h> | |||
#include <qfontmetrics.h> | ||||
#include <qglyphrun.h> | ||||
r5 | #include <qgraphicseffect.h> | |||
#include <qgraphicsproxywidget.h> | ||||
#include <qicon.h> | ||||
r6 | #include <qimage.h> | |||
r5 | #include <qkeysequence.h> | |||
#include <qlayout.h> | ||||
r6 | #include <qline.h> | |||
r5 | #include <qlist.h> | |||
#include <qlocale.h> | ||||
r6 | #include <qlopdata.h> | |||
r5 | #include <qmargins.h> | |||
r6 | #include <qmatrix.h> | |||
r5 | #include <qmetaobject.h> | |||
#include <qobject.h> | ||||
#include <qpaintdevice.h> | ||||
#include <qpaintengine.h> | ||||
#include <qpainter.h> | ||||
r6 | #include <qpainterpath.h> | |||
r5 | #include <qpalette.h> | |||
#include <qpen.h> | ||||
r6 | #include <qpicture.h> | |||
r5 | #include <qpixmap.h> | |||
#include <qpoint.h> | ||||
r6 | #include <qpolygon.h> | |||
r5 | #include <qrect.h> | |||
#include <qregion.h> | ||||
#include <qsize.h> | ||||
#include <qsizepolicy.h> | ||||
r6 | #include <qstatictext.h> | |||
#include <qstringlist.h> | ||||
r5 | #include <qstyle.h> | |||
r6 | #include <qstyleoption.h> | |||
#include <qtextoption.h> | ||||
#include <qtransform.h> | ||||
#include <qvector.h> | ||||
r5 | #include <qwidget.h> | |||
#include <qwindow.h> | ||||
r6 | PythonQtShell_FileBrowser::~PythonQtShell_FileBrowser() { | |||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_FileBrowser::actionEvent(QActionEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("actionEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::changeEvent(QEvent* e0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("changeEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::changeEvent(e0); | ||||
} | ||||
void PythonQtShell_FileBrowser::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::closeEvent(QCloseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("closeEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCloseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::closeEvent(event0); | ||||
} | ||||
void PythonQtShell_FileBrowser::contextMenuEvent(QContextMenuEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("contextMenuEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_FileBrowser::devType() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("devType"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::devType(); | ||||
} | ||||
void PythonQtShell_FileBrowser::dragEnterEvent(QDragEnterEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("dragEnterEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::dragLeaveEvent(QDragLeaveEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("dragLeaveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::dragMoveEvent(QDragMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("dragMoveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::dropEvent(QDropEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("dropEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::enterEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("enterEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_FileBrowser::event(QEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::event(event0); | ||||
} | ||||
bool PythonQtShell_FileBrowser::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_FileBrowser::focusInEvent(QFocusEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("focusInEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_FileBrowser::focusNextPrevChild(bool next0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("focusNextPrevChild"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"bool" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&next0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::focusNextPrevChild(next0); | ||||
} | ||||
void PythonQtShell_FileBrowser::focusOutEvent(QFocusEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("focusOutEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::focusOutEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_FileBrowser::hasHeightForWidth() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("hasHeightForWidth"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::hasHeightForWidth(); | ||||
} | ||||
int PythonQtShell_FileBrowser::heightForWidth(int arg__1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("heightForWidth"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::hideEvent(QHideEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("hideEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::initPainter(QPainter* painter0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("initPainter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::initPainter(painter0); | ||||
} | ||||
void PythonQtShell_FileBrowser::inputMethodEvent(QInputMethodEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("inputMethodEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_FileBrowser::inputMethodQuery(Qt::InputMethodQuery arg__1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("inputMethodQuery"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::keyPressEvent(QKeyEvent* e0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("keyPressEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&e0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::keyPressEvent(e0); | ||||
} | ||||
void PythonQtShell_FileBrowser::keyReleaseEvent(QKeyEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("keyReleaseEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::leaveEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("leaveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_FileBrowser::metric(QPaintDevice::PaintDeviceMetric arg__1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("metric"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::metric(arg__1); | ||||
} | ||||
QSize PythonQtShell_FileBrowser::minimumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("getMinimumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_FileBrowser::mouseDoubleClickEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseDoubleClickEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::mouseMoveEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseMoveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::mousePressEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mousePressEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::mouseReleaseEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseReleaseEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::moveEvent(QMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("moveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::moveEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_FileBrowser::nativeEvent(const QByteArray& eventType0, void* message1, long* result2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("nativeEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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*)&eventType0, (void*)&message1, (void*)&result2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::nativeEvent(eventType0, message1, result2); | ||||
} | ||||
QPaintEngine* PythonQtShell_FileBrowser::paintEngine() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("paintEngine"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::paintEngine(); | ||||
} | ||||
void PythonQtShell_FileBrowser::paintEvent(QPaintEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("paintEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QPaintEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::paintEvent(event0); | ||||
} | ||||
QPaintDevice* PythonQtShell_FileBrowser::redirected(QPoint* offset0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("redirected"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPaintDevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&offset0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::redirected(offset0); | ||||
} | ||||
void PythonQtShell_FileBrowser::resizeEvent(QResizeEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("resizeEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::resizeEvent(arg__1); | ||||
} | ||||
QPainter* PythonQtShell_FileBrowser::sharedPainter() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("sharedPainter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::sharedPainter(); | ||||
} | ||||
void PythonQtShell_FileBrowser::showEvent(QShowEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("showEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::showEvent(arg__1); | ||||
} | ||||
QSize PythonQtShell_FileBrowser::sizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("getSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return FileBrowser::sizeHint(); | ||||
} | ||||
void PythonQtShell_FileBrowser::tabletEvent(QTabletEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("tabletEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_FileBrowser::wheelEvent(QWheelEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("wheelEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
FileBrowser::wheelEvent(arg__1); | ||||
} | ||||
FileBrowser* PythonQtWrapper_FileBrowser::new_FileBrowser(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_FileBrowser(parent); } | ||||
void PythonQtWrapper_FileBrowser::changeEvent(FileBrowser* theWrappedObject, QEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_FileBrowser*)theWrappedObject)->promoted_changeEvent(e)); | ||||
} | ||||
void PythonQtWrapper_FileBrowser::keyPressEvent(FileBrowser* theWrappedObject, QKeyEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_FileBrowser*)theWrappedObject)->promoted_keyPressEvent(e)); | ||||
} | ||||
void PythonQtWrapper_FileBrowser::setNameFilters(FileBrowser* theWrappedObject, const QStringList& filters, bool disables) | ||||
{ | ||||
( theWrappedObject->setNameFilters(filters, disables)); | ||||
} | ||||
PythonQtShell_QCPAbstractItem::~PythonQtShell_QCPAbstractItem() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QPointF PythonQtShell_QCPAbstractItem::anchorPixelPoint(int anchorId0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("anchorPixelPoint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QPointF" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPointF returnValue; | ||||
void* args[2] = {NULL, (void*)&anchorId0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("anchorPixelPoint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPointF*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAbstractItem::anchorPixelPoint(anchorId0); | ||||
} | ||||
void PythonQtShell_QCPAbstractItem::applyDefaultAntialiasingHint(QCPPainter* painter0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractItem::applyDefaultAntialiasingHint(painter0); | ||||
} | ||||
void PythonQtShell_QCPAbstractItem::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractItem::childEvent(arg__1); | ||||
} | ||||
QRect PythonQtShell_QCPAbstractItem::clipRect() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("clipRect"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QRect"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QRect 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("clipRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAbstractItem::clipRect(); | ||||
} | ||||
void PythonQtShell_QCPAbstractItem::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractItem::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPAbstractItem::deselectEvent(bool* selectionStateChanged0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("deselectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&selectionStateChanged0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractItem::deselectEvent(selectionStateChanged0); | ||||
} | ||||
void PythonQtShell_QCPAbstractItem::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
} | ||||
bool PythonQtShell_QCPAbstractItem::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAbstractItem::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QCPAbstractItem::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAbstractItem::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QCPAbstractItem::parentPlotInitialized(QCustomPlot* parentPlot0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("parentPlotInitialized"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCustomPlot*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&parentPlot0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractItem::parentPlotInitialized(parentPlot0); | ||||
} | ||||
void PythonQtShell_QCPAbstractItem::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractItem::selectEvent(event0, additive1, details2, selectionStateChanged3); | ||||
} | ||||
double PythonQtShell_QCPAbstractItem::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectTest"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
double returnValue; | ||||
void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result); | ||||
} else { | ||||
returnValue = *((double*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return double(); | ||||
} | ||||
void PythonQtShell_QCPAbstractItem::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractItem::timerEvent(arg__1); | ||||
} | ||||
QCPAbstractItem* PythonQtWrapper_QCPAbstractItem::new_QCPAbstractItem(QCustomPlot* parentPlot) | ||||
{ | ||||
return new PythonQtShell_QCPAbstractItem(parentPlot); } | ||||
QPointF PythonQtWrapper_QCPAbstractItem::anchorPixelPoint(QCPAbstractItem* theWrappedObject, int anchorId) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_anchorPixelPoint(anchorId)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractItem::applyDefaultAntialiasingHint(QCPAbstractItem* theWrappedObject, QCPPainter* painter) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter)); | ||||
} | ||||
QCPAxisRect* PythonQtWrapper_QCPAbstractItem::clipAxisRect(QCPAbstractItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->clipAxisRect()); | ||||
} | ||||
QRect PythonQtWrapper_QCPAbstractItem::clipRect(QCPAbstractItem* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_clipRect()); | ||||
} | ||||
bool PythonQtWrapper_QCPAbstractItem::clipToAxisRect(QCPAbstractItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->clipToAxisRect()); | ||||
} | ||||
QCPItemPosition* PythonQtWrapper_QCPAbstractItem::createPosition(QCPAbstractItem* theWrappedObject, const QString& name) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_createPosition(name)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractItem::deselectEvent(QCPAbstractItem* theWrappedObject, bool* selectionStateChanged) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged)); | ||||
} | ||||
double PythonQtWrapper_QCPAbstractItem::distSqrToLine(QCPAbstractItem* theWrappedObject, const QPointF& start, const QPointF& end, const QPointF& point) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_distSqrToLine(start, end, point)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractItem::draw(QCPAbstractItem* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_draw(painter)); | ||||
} | ||||
bool PythonQtWrapper_QCPAbstractItem::hasAnchor(QCPAbstractItem* theWrappedObject, const QString& name) const | ||||
{ | ||||
return ( theWrappedObject->hasAnchor(name)); | ||||
} | ||||
QCPItemPosition* PythonQtWrapper_QCPAbstractItem::position(QCPAbstractItem* theWrappedObject, const QString& name) const | ||||
{ | ||||
return ( theWrappedObject->position(name)); | ||||
} | ||||
QList<QCPItemPosition* > PythonQtWrapper_QCPAbstractItem::positions(QCPAbstractItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->positions()); | ||||
} | ||||
double PythonQtWrapper_QCPAbstractItem::rectSelectTest(QCPAbstractItem* theWrappedObject, const QRectF& rect, const QPointF& pos, bool filledRect) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_rectSelectTest(rect, pos, filledRect)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractItem::selectEvent(QCPAbstractItem* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged)); | ||||
} | ||||
double PythonQtWrapper_QCPAbstractItem::selectTest(QCPAbstractItem* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details)); | ||||
} | ||||
bool PythonQtWrapper_QCPAbstractItem::selectable(QCPAbstractItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectable()); | ||||
} | ||||
bool PythonQtWrapper_QCPAbstractItem::selected(QCPAbstractItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selected()); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractItem::setClipAxisRect(QCPAbstractItem* theWrappedObject, QCPAxisRect* rect) | ||||
{ | ||||
( theWrappedObject->setClipAxisRect(rect)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractItem::setClipToAxisRect(QCPAbstractItem* theWrappedObject, bool clip) | ||||
{ | ||||
( theWrappedObject->setClipToAxisRect(clip)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractItem::setSelectable(QCPAbstractItem* theWrappedObject, bool selectable) | ||||
{ | ||||
( theWrappedObject->setSelectable(selectable)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractItem::setSelected(QCPAbstractItem* theWrappedObject, bool selected) | ||||
{ | ||||
( theWrappedObject->setSelected(selected)); | ||||
} | ||||
PythonQtShell_QCPAbstractLegendItem::~PythonQtShell_QCPAbstractLegendItem() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::applyDefaultAntialiasingHint(QCPPainter* painter0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractLegendItem::applyDefaultAntialiasingHint(painter0); | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractLegendItem::childEvent(arg__1); | ||||
} | ||||
QRect PythonQtShell_QCPAbstractLegendItem::clipRect() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("clipRect"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QRect"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QRect 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("clipRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAbstractLegendItem::clipRect(); | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractLegendItem::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::deselectEvent(bool* selectionStateChanged0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("deselectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&selectionStateChanged0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractLegendItem::deselectEvent(selectionStateChanged0); | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
} | ||||
QList<QCPLayoutElement* > PythonQtShell_QCPAbstractLegendItem::elements(bool recursive0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("elements"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QList<QCPLayoutElement* > returnValue; | ||||
void* args[2] = {NULL, (void*)&recursive0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QList<QCPLayoutElement* >*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAbstractLegendItem::elements(recursive0); | ||||
} | ||||
bool PythonQtShell_QCPAbstractLegendItem::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAbstractLegendItem::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QCPAbstractLegendItem::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAbstractLegendItem::eventFilter(arg__1, arg__2); | ||||
} | ||||
QSize PythonQtShell_QCPAbstractLegendItem::maximumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("maximumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("maximumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAbstractLegendItem::maximumSizeHint(); | ||||
} | ||||
QSize PythonQtShell_QCPAbstractLegendItem::minimumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("minimumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("minimumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAbstractLegendItem::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::mouseDoubleClickEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseDoubleClickEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractLegendItem::mouseDoubleClickEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::mouseMoveEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseMoveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractLegendItem::mouseMoveEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::mousePressEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mousePressEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractLegendItem::mousePressEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::mouseReleaseEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseReleaseEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractLegendItem::mouseReleaseEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::parentPlotInitialized(QCustomPlot* parentPlot0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("parentPlotInitialized"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCustomPlot*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&parentPlot0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractLegendItem::parentPlotInitialized(parentPlot0); | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractLegendItem::selectEvent(event0, additive1, details2, selectionStateChanged3); | ||||
} | ||||
double PythonQtShell_QCPAbstractLegendItem::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectTest"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
double returnValue; | ||||
void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result); | ||||
} else { | ||||
returnValue = *((double*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAbstractLegendItem::selectTest(pos0, onlySelectable1, details2); | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractLegendItem::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPAbstractLegendItem::wheelEvent(QWheelEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("wheelEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAbstractLegendItem::wheelEvent(event0); | ||||
} | ||||
QCPAbstractLegendItem* PythonQtWrapper_QCPAbstractLegendItem::new_QCPAbstractLegendItem(QCPLegend* parent) | ||||
{ | ||||
return new PythonQtShell_QCPAbstractLegendItem(parent); } | ||||
void PythonQtWrapper_QCPAbstractLegendItem::applyDefaultAntialiasingHint(QCPAbstractLegendItem* theWrappedObject, QCPPainter* painter) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter)); | ||||
} | ||||
QRect PythonQtWrapper_QCPAbstractLegendItem::clipRect(QCPAbstractLegendItem* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_clipRect()); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractLegendItem::deselectEvent(QCPAbstractLegendItem* theWrappedObject, bool* selectionStateChanged) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractLegendItem::draw(QCPAbstractLegendItem* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_draw(painter)); | ||||
} | ||||
QFont PythonQtWrapper_QCPAbstractLegendItem::font(QCPAbstractLegendItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->font()); | ||||
} | ||||
QCPLegend* PythonQtWrapper_QCPAbstractLegendItem::parentLegend(QCPAbstractLegendItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->parentLegend()); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractLegendItem::selectEvent(QCPAbstractLegendItem* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged)); | ||||
} | ||||
double PythonQtWrapper_QCPAbstractLegendItem::selectTest(QCPAbstractLegendItem* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details)); | ||||
} | ||||
bool PythonQtWrapper_QCPAbstractLegendItem::selectable(QCPAbstractLegendItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectable()); | ||||
} | ||||
bool PythonQtWrapper_QCPAbstractLegendItem::selected(QCPAbstractLegendItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selected()); | ||||
} | ||||
QFont PythonQtWrapper_QCPAbstractLegendItem::selectedFont(QCPAbstractLegendItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedFont()); | ||||
} | ||||
QColor PythonQtWrapper_QCPAbstractLegendItem::selectedTextColor(QCPAbstractLegendItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedTextColor()); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractLegendItem::setFont(QCPAbstractLegendItem* theWrappedObject, const QFont& font) | ||||
{ | ||||
( theWrappedObject->setFont(font)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractLegendItem::setSelectable(QCPAbstractLegendItem* theWrappedObject, bool selectable) | ||||
{ | ||||
( theWrappedObject->setSelectable(selectable)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractLegendItem::setSelected(QCPAbstractLegendItem* theWrappedObject, bool selected) | ||||
{ | ||||
( theWrappedObject->setSelected(selected)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractLegendItem::setSelectedFont(QCPAbstractLegendItem* theWrappedObject, const QFont& font) | ||||
{ | ||||
( theWrappedObject->setSelectedFont(font)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractLegendItem::setSelectedTextColor(QCPAbstractLegendItem* theWrappedObject, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setSelectedTextColor(color)); | ||||
} | ||||
void PythonQtWrapper_QCPAbstractLegendItem::setTextColor(QCPAbstractLegendItem* theWrappedObject, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setTextColor(color)); | ||||
} | ||||
QColor PythonQtWrapper_QCPAbstractLegendItem::textColor(QCPAbstractLegendItem* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textColor()); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::applyDefaultAntialiasingHint(QCPAxis* theWrappedObject, QCPPainter* painter) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter)); | ||||
} | ||||
bool PythonQtWrapper_QCPAxis::autoSubTicks(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoSubTicks()); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::autoTickCount(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoTickCount()); | ||||
} | ||||
bool PythonQtWrapper_QCPAxis::autoTickLabels(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoTickLabels()); | ||||
} | ||||
bool PythonQtWrapper_QCPAxis::autoTickStep(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoTickStep()); | ||||
} | ||||
bool PythonQtWrapper_QCPAxis::autoTicks(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoTicks()); | ||||
} | ||||
QCPAxisRect* PythonQtWrapper_QCPAxis::axisRect(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->axisRect()); | ||||
} | ||||
double PythonQtWrapper_QCPAxis::baseLog(QCPAxis* theWrappedObject, double value) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_baseLog(value)); | ||||
} | ||||
QPen PythonQtWrapper_QCPAxis::basePen(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->basePen()); | ||||
} | ||||
double PythonQtWrapper_QCPAxis::basePow(QCPAxis* theWrappedObject, double value) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_basePow(value)); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::calculateAutoSubTickCount(QCPAxis* theWrappedObject, double tickStep) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_calculateAutoSubTickCount(tickStep)); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::calculateMargin(QCPAxis* theWrappedObject) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_calculateMargin()); | ||||
} | ||||
double PythonQtWrapper_QCPAxis::coordToPixel(QCPAxis* theWrappedObject, double value) const | ||||
{ | ||||
return ( theWrappedObject->coordToPixel(value)); | ||||
} | ||||
QString PythonQtWrapper_QCPAxis::dateTimeFormat(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->dateTimeFormat()); | ||||
} | ||||
Qt::TimeSpec PythonQtWrapper_QCPAxis::dateTimeSpec(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->dateTimeSpec()); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::deselectEvent(QCPAxis* theWrappedObject, bool* selectionStateChanged) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::draw(QCPAxis* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_draw(painter)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::generateAutoTicks(QCPAxis* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_generateAutoTicks()); | ||||
} | ||||
QPen PythonQtWrapper_QCPAxis::getBasePen(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getBasePen()); | ||||
} | ||||
QColor PythonQtWrapper_QCPAxis::getLabelColor(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getLabelColor()); | ||||
} | ||||
QFont PythonQtWrapper_QCPAxis::getLabelFont(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getLabelFont()); | ||||
} | ||||
QPen PythonQtWrapper_QCPAxis::getSubTickPen(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getSubTickPen()); | ||||
} | ||||
QColor PythonQtWrapper_QCPAxis::getTickLabelColor(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getTickLabelColor()); | ||||
} | ||||
QFont PythonQtWrapper_QCPAxis::getTickLabelFont(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getTickLabelFont()); | ||||
} | ||||
QPen PythonQtWrapper_QCPAxis::getTickPen(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getTickPen()); | ||||
} | ||||
QList<QCPGraph* > PythonQtWrapper_QCPAxis::graphs(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->graphs()); | ||||
} | ||||
QList<QCPAbstractItem* > PythonQtWrapper_QCPAxis::items(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->items()); | ||||
} | ||||
QString PythonQtWrapper_QCPAxis::label(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->label()); | ||||
} | ||||
QColor PythonQtWrapper_QCPAxis::labelColor(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->labelColor()); | ||||
} | ||||
QFont PythonQtWrapper_QCPAxis::labelFont(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->labelFont()); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::labelPadding(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->labelPadding()); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::moveRange(QCPAxis* theWrappedObject, double diff) | ||||
{ | ||||
( theWrappedObject->moveRange(diff)); | ||||
} | ||||
QString PythonQtWrapper_QCPAxis::numberFormat(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->numberFormat()); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::numberPrecision(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->numberPrecision()); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::offset(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->offset()); | ||||
} | ||||
Qt::Orientation PythonQtWrapper_QCPAxis::orientation(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->orientation()); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::padding(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->padding()); | ||||
} | ||||
double PythonQtWrapper_QCPAxis::pixelToCoord(QCPAxis* theWrappedObject, double value) const | ||||
{ | ||||
return ( theWrappedObject->pixelToCoord(value)); | ||||
} | ||||
bool PythonQtWrapper_QCPAxis::rangeReversed(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rangeReversed()); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::rescale(QCPAxis* theWrappedObject, bool onlyVisiblePlottables) | ||||
{ | ||||
( theWrappedObject->rescale(onlyVisiblePlottables)); | ||||
} | ||||
double PythonQtWrapper_QCPAxis::scaleLogBase(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->scaleLogBase()); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::scaleRange(QCPAxis* theWrappedObject, double factor, double center) | ||||
{ | ||||
( theWrappedObject->scaleRange(factor, center)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::selectEvent(QCPAxis* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged)); | ||||
} | ||||
double PythonQtWrapper_QCPAxis::selectTest(QCPAxis* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details)); | ||||
} | ||||
QPen PythonQtWrapper_QCPAxis::selectedBasePen(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedBasePen()); | ||||
} | ||||
QColor PythonQtWrapper_QCPAxis::selectedLabelColor(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedLabelColor()); | ||||
} | ||||
QFont PythonQtWrapper_QCPAxis::selectedLabelFont(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedLabelFont()); | ||||
} | ||||
QPen PythonQtWrapper_QCPAxis::selectedSubTickPen(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedSubTickPen()); | ||||
} | ||||
QColor PythonQtWrapper_QCPAxis::selectedTickLabelColor(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedTickLabelColor()); | ||||
} | ||||
QFont PythonQtWrapper_QCPAxis::selectedTickLabelFont(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedTickLabelFont()); | ||||
} | ||||
QPen PythonQtWrapper_QCPAxis::selectedTickPen(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedTickPen()); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setAutoSubTicks(QCPAxis* theWrappedObject, bool on) | ||||
{ | ||||
( theWrappedObject->setAutoSubTicks(on)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setAutoTickCount(QCPAxis* theWrappedObject, int approximateCount) | ||||
{ | ||||
( theWrappedObject->setAutoTickCount(approximateCount)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setAutoTickLabels(QCPAxis* theWrappedObject, bool on) | ||||
{ | ||||
( theWrappedObject->setAutoTickLabels(on)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setAutoTickStep(QCPAxis* theWrappedObject, bool on) | ||||
{ | ||||
( theWrappedObject->setAutoTickStep(on)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setAutoTicks(QCPAxis* theWrappedObject, bool on) | ||||
{ | ||||
( theWrappedObject->setAutoTicks(on)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setBasePen(QCPAxis* theWrappedObject, const QPen& pen) | ||||
{ | ||||
( theWrappedObject->setBasePen(pen)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setDateTimeFormat(QCPAxis* theWrappedObject, const QString& format) | ||||
{ | ||||
( theWrappedObject->setDateTimeFormat(format)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setDateTimeSpec(QCPAxis* theWrappedObject, const Qt::TimeSpec& timeSpec) | ||||
{ | ||||
( theWrappedObject->setDateTimeSpec(timeSpec)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setLabel(QCPAxis* theWrappedObject, const QString& str) | ||||
{ | ||||
( theWrappedObject->setLabel(str)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setLabelColor(QCPAxis* theWrappedObject, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setLabelColor(color)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setLabelFont(QCPAxis* theWrappedObject, const QFont& font) | ||||
{ | ||||
( theWrappedObject->setLabelFont(font)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setLabelPadding(QCPAxis* theWrappedObject, int padding) | ||||
{ | ||||
( theWrappedObject->setLabelPadding(padding)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setNumberFormat(QCPAxis* theWrappedObject, const QString& formatCode) | ||||
{ | ||||
( theWrappedObject->setNumberFormat(formatCode)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setNumberPrecision(QCPAxis* theWrappedObject, int precision) | ||||
{ | ||||
( theWrappedObject->setNumberPrecision(precision)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setOffset(QCPAxis* theWrappedObject, int offset) | ||||
{ | ||||
( theWrappedObject->setOffset(offset)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setPadding(QCPAxis* theWrappedObject, int padding) | ||||
{ | ||||
( theWrappedObject->setPadding(padding)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setRange(QCPAxis* theWrappedObject, double lower, double upper) | ||||
{ | ||||
( theWrappedObject->setRange(lower, upper)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setRange(QCPAxis* theWrappedObject, double position, double size, Qt::AlignmentFlag alignment) | ||||
{ | ||||
( theWrappedObject->setRange(position, size, alignment)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setRangeLower(QCPAxis* theWrappedObject, double lower) | ||||
{ | ||||
( theWrappedObject->setRangeLower(lower)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setRangeReversed(QCPAxis* theWrappedObject, bool reversed) | ||||
{ | ||||
( theWrappedObject->setRangeReversed(reversed)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setRangeUpper(QCPAxis* theWrappedObject, double upper) | ||||
{ | ||||
( theWrappedObject->setRangeUpper(upper)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setScaleLogBase(QCPAxis* theWrappedObject, double base) | ||||
{ | ||||
( theWrappedObject->setScaleLogBase(base)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setScaleRatio(QCPAxis* theWrappedObject, const QCPAxis* otherAxis, double ratio) | ||||
{ | ||||
( theWrappedObject->setScaleRatio(otherAxis, ratio)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setSelectedBasePen(QCPAxis* theWrappedObject, const QPen& pen) | ||||
{ | ||||
( theWrappedObject->setSelectedBasePen(pen)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setSelectedLabelColor(QCPAxis* theWrappedObject, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setSelectedLabelColor(color)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setSelectedLabelFont(QCPAxis* theWrappedObject, const QFont& font) | ||||
{ | ||||
( theWrappedObject->setSelectedLabelFont(font)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setSelectedSubTickPen(QCPAxis* theWrappedObject, const QPen& pen) | ||||
{ | ||||
( theWrappedObject->setSelectedSubTickPen(pen)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setSelectedTickLabelColor(QCPAxis* theWrappedObject, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setSelectedTickLabelColor(color)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setSelectedTickLabelFont(QCPAxis* theWrappedObject, const QFont& font) | ||||
{ | ||||
( theWrappedObject->setSelectedTickLabelFont(font)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setSelectedTickPen(QCPAxis* theWrappedObject, const QPen& pen) | ||||
{ | ||||
( theWrappedObject->setSelectedTickPen(pen)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setSubTickCount(QCPAxis* theWrappedObject, int count) | ||||
{ | ||||
( theWrappedObject->setSubTickCount(count)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setSubTickLength(QCPAxis* theWrappedObject, int inside, int outside) | ||||
{ | ||||
( theWrappedObject->setSubTickLength(inside, outside)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setSubTickLengthIn(QCPAxis* theWrappedObject, int inside) | ||||
{ | ||||
( theWrappedObject->setSubTickLengthIn(inside)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setSubTickLengthOut(QCPAxis* theWrappedObject, int outside) | ||||
{ | ||||
( theWrappedObject->setSubTickLengthOut(outside)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setSubTickPen(QCPAxis* theWrappedObject, const QPen& pen) | ||||
{ | ||||
( theWrappedObject->setSubTickPen(pen)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTickLabelColor(QCPAxis* theWrappedObject, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setTickLabelColor(color)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTickLabelFont(QCPAxis* theWrappedObject, const QFont& font) | ||||
{ | ||||
( theWrappedObject->setTickLabelFont(font)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTickLabelPadding(QCPAxis* theWrappedObject, int padding) | ||||
{ | ||||
( theWrappedObject->setTickLabelPadding(padding)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTickLabelRotation(QCPAxis* theWrappedObject, double degrees) | ||||
{ | ||||
( theWrappedObject->setTickLabelRotation(degrees)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTickLabels(QCPAxis* theWrappedObject, bool show) | ||||
{ | ||||
( theWrappedObject->setTickLabels(show)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTickLength(QCPAxis* theWrappedObject, int inside, int outside) | ||||
{ | ||||
( theWrappedObject->setTickLength(inside, outside)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTickLengthIn(QCPAxis* theWrappedObject, int inside) | ||||
{ | ||||
( theWrappedObject->setTickLengthIn(inside)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTickLengthOut(QCPAxis* theWrappedObject, int outside) | ||||
{ | ||||
( theWrappedObject->setTickLengthOut(outside)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTickPen(QCPAxis* theWrappedObject, const QPen& pen) | ||||
{ | ||||
( theWrappedObject->setTickPen(pen)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTickStep(QCPAxis* theWrappedObject, double step) | ||||
{ | ||||
( theWrappedObject->setTickStep(step)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTickVector(QCPAxis* theWrappedObject, const QVector<double >& vec) | ||||
{ | ||||
( theWrappedObject->setTickVector(vec)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTickVectorLabels(QCPAxis* theWrappedObject, const QVector<QString >& vec) | ||||
{ | ||||
( theWrappedObject->setTickVectorLabels(vec)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setTicks(QCPAxis* theWrappedObject, bool show) | ||||
{ | ||||
( theWrappedObject->setTicks(show)); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::setupTickVectors(QCPAxis* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_setupTickVectors()); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::subTickCount(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->subTickCount()); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::subTickLengthIn(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->subTickLengthIn()); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::subTickLengthOut(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->subTickLengthOut()); | ||||
} | ||||
QPen PythonQtWrapper_QCPAxis::subTickPen(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->subTickPen()); | ||||
} | ||||
QColor PythonQtWrapper_QCPAxis::tickLabelColor(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tickLabelColor()); | ||||
} | ||||
QFont PythonQtWrapper_QCPAxis::tickLabelFont(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tickLabelFont()); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::tickLabelPadding(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tickLabelPadding()); | ||||
} | ||||
double PythonQtWrapper_QCPAxis::tickLabelRotation(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tickLabelRotation()); | ||||
} | ||||
bool PythonQtWrapper_QCPAxis::tickLabels(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tickLabels()); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::tickLengthIn(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tickLengthIn()); | ||||
} | ||||
int PythonQtWrapper_QCPAxis::tickLengthOut(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tickLengthOut()); | ||||
} | ||||
QPen PythonQtWrapper_QCPAxis::tickPen(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tickPen()); | ||||
} | ||||
double PythonQtWrapper_QCPAxis::tickStep(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tickStep()); | ||||
} | ||||
QVector<double > PythonQtWrapper_QCPAxis::tickVector(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tickVector()); | ||||
} | ||||
QVector<QString > PythonQtWrapper_QCPAxis::tickVectorLabels(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tickVectorLabels()); | ||||
} | ||||
bool PythonQtWrapper_QCPAxis::ticks(QCPAxis* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->ticks()); | ||||
} | ||||
void PythonQtWrapper_QCPAxis::visibleTickBounds(QCPAxis* theWrappedObject, int& lowIndex, int& highIndex) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_visibleTickBounds(lowIndex, highIndex)); | ||||
} | ||||
PythonQtShell_QCPAxisRect::~PythonQtShell_QCPAxisRect() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCPAxisRect::applyDefaultAntialiasingHint(QCPPainter* painter0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::applyDefaultAntialiasingHint(painter0); | ||||
} | ||||
void PythonQtShell_QCPAxisRect::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::childEvent(arg__1); | ||||
} | ||||
QRect PythonQtShell_QCPAxisRect::clipRect() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("clipRect"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QRect"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QRect 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("clipRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAxisRect::clipRect(); | ||||
} | ||||
void PythonQtShell_QCPAxisRect::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPAxisRect::deselectEvent(bool* selectionStateChanged0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("deselectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&selectionStateChanged0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::deselectEvent(selectionStateChanged0); | ||||
} | ||||
void PythonQtShell_QCPAxisRect::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::draw(painter0); | ||||
} | ||||
QList<QCPLayoutElement* > PythonQtShell_QCPAxisRect::elements(bool recursive0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("elements"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QList<QCPLayoutElement* > returnValue; | ||||
void* args[2] = {NULL, (void*)&recursive0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QList<QCPLayoutElement* >*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAxisRect::elements(recursive0); | ||||
} | ||||
bool PythonQtShell_QCPAxisRect::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAxisRect::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QCPAxisRect::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAxisRect::eventFilter(arg__1, arg__2); | ||||
} | ||||
QSize PythonQtShell_QCPAxisRect::maximumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("maximumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("maximumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAxisRect::maximumSizeHint(); | ||||
} | ||||
QSize PythonQtShell_QCPAxisRect::minimumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("minimumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("minimumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAxisRect::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QCPAxisRect::mouseDoubleClickEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseDoubleClickEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::mouseDoubleClickEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPAxisRect::mouseMoveEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseMoveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::mouseMoveEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPAxisRect::mousePressEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mousePressEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::mousePressEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPAxisRect::mouseReleaseEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseReleaseEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::mouseReleaseEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPAxisRect::parentPlotInitialized(QCustomPlot* parentPlot0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("parentPlotInitialized"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCustomPlot*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&parentPlot0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::parentPlotInitialized(parentPlot0); | ||||
} | ||||
void PythonQtShell_QCPAxisRect::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::selectEvent(event0, additive1, details2, selectionStateChanged3); | ||||
} | ||||
double PythonQtShell_QCPAxisRect::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectTest"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
double returnValue; | ||||
void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result); | ||||
} else { | ||||
returnValue = *((double*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPAxisRect::selectTest(pos0, onlySelectable1, details2); | ||||
} | ||||
void PythonQtShell_QCPAxisRect::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPAxisRect::wheelEvent(QWheelEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("wheelEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPAxisRect::wheelEvent(event0); | ||||
} | ||||
QCPAxisRect* PythonQtWrapper_QCPAxisRect::new_QCPAxisRect(QCustomPlot* parentPlot, bool setupDefaultAxes) | ||||
{ | ||||
return new PythonQtShell_QCPAxisRect(parentPlot, setupDefaultAxes); } | ||||
void PythonQtWrapper_QCPAxisRect::applyDefaultAntialiasingHint(QCPAxisRect* theWrappedObject, QCPPainter* painter) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter)); | ||||
} | ||||
QList<QCPAxis* > PythonQtWrapper_QCPAxisRect::axes(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->axes()); | ||||
} | ||||
QPixmap PythonQtWrapper_QCPAxisRect::background(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->background()); | ||||
} | ||||
bool PythonQtWrapper_QCPAxisRect::backgroundScaled(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->backgroundScaled()); | ||||
} | ||||
Qt::AspectRatioMode PythonQtWrapper_QCPAxisRect::backgroundScaledMode(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->backgroundScaledMode()); | ||||
} | ||||
int PythonQtWrapper_QCPAxisRect::bottom(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->bottom()); | ||||
} | ||||
QPoint PythonQtWrapper_QCPAxisRect::bottomLeft(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->bottomLeft()); | ||||
} | ||||
QPoint PythonQtWrapper_QCPAxisRect::bottomRight(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->bottomRight()); | ||||
} | ||||
QPoint PythonQtWrapper_QCPAxisRect::center(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->center()); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::draw(QCPAxisRect* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_draw(painter)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::drawBackground(QCPAxisRect* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_drawBackground(painter)); | ||||
} | ||||
QList<QCPLayoutElement* > PythonQtWrapper_QCPAxisRect::elements(QCPAxisRect* theWrappedObject, bool recursive) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_elements(recursive)); | ||||
} | ||||
QList<QCPGraph* > PythonQtWrapper_QCPAxisRect::graphs(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->graphs()); | ||||
} | ||||
int PythonQtWrapper_QCPAxisRect::height(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->height()); | ||||
} | ||||
QList<QCPAbstractItem* > PythonQtWrapper_QCPAxisRect::items(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->items()); | ||||
} | ||||
int PythonQtWrapper_QCPAxisRect::left(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->left()); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::mouseMoveEvent(QCPAxisRect* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_mouseMoveEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::mousePressEvent(QCPAxisRect* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_mousePressEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::mouseReleaseEvent(QCPAxisRect* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_mouseReleaseEvent(event)); | ||||
} | ||||
Qt::Orientations PythonQtWrapper_QCPAxisRect::rangeDrag(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rangeDrag()); | ||||
} | ||||
QCPAxis* PythonQtWrapper_QCPAxisRect::rangeDragAxis(QCPAxisRect* theWrappedObject, Qt::Orientation orientation) | ||||
{ | ||||
return ( theWrappedObject->rangeDragAxis(orientation)); | ||||
} | ||||
Qt::Orientations PythonQtWrapper_QCPAxisRect::rangeZoom(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rangeZoom()); | ||||
} | ||||
QCPAxis* PythonQtWrapper_QCPAxisRect::rangeZoomAxis(QCPAxisRect* theWrappedObject, Qt::Orientation orientation) | ||||
{ | ||||
return ( theWrappedObject->rangeZoomAxis(orientation)); | ||||
} | ||||
double PythonQtWrapper_QCPAxisRect::rangeZoomFactor(QCPAxisRect* theWrappedObject, Qt::Orientation orientation) | ||||
{ | ||||
return ( theWrappedObject->rangeZoomFactor(orientation)); | ||||
} | ||||
bool PythonQtWrapper_QCPAxisRect::removeAxis(QCPAxisRect* theWrappedObject, QCPAxis* axis) | ||||
{ | ||||
return ( theWrappedObject->removeAxis(axis)); | ||||
} | ||||
int PythonQtWrapper_QCPAxisRect::right(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->right()); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::setBackground(QCPAxisRect* theWrappedObject, const QBrush& brush) | ||||
{ | ||||
( theWrappedObject->setBackground(brush)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::setBackground(QCPAxisRect* theWrappedObject, const QPixmap& pm) | ||||
{ | ||||
( theWrappedObject->setBackground(pm)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::setBackground(QCPAxisRect* theWrappedObject, const QPixmap& pm, bool scaled, Qt::AspectRatioMode mode) | ||||
{ | ||||
( theWrappedObject->setBackground(pm, scaled, mode)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::setBackgroundScaled(QCPAxisRect* theWrappedObject, bool scaled) | ||||
{ | ||||
( theWrappedObject->setBackgroundScaled(scaled)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::setBackgroundScaledMode(QCPAxisRect* theWrappedObject, Qt::AspectRatioMode mode) | ||||
{ | ||||
( theWrappedObject->setBackgroundScaledMode(mode)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::setRangeDrag(QCPAxisRect* theWrappedObject, Qt::Orientations orientations) | ||||
{ | ||||
( theWrappedObject->setRangeDrag(orientations)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::setRangeDragAxes(QCPAxisRect* theWrappedObject, QCPAxis* horizontal, QCPAxis* vertical) | ||||
{ | ||||
( theWrappedObject->setRangeDragAxes(horizontal, vertical)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::setRangeZoom(QCPAxisRect* theWrappedObject, Qt::Orientations orientations) | ||||
{ | ||||
( theWrappedObject->setRangeZoom(orientations)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::setRangeZoomAxes(QCPAxisRect* theWrappedObject, QCPAxis* horizontal, QCPAxis* vertical) | ||||
{ | ||||
( theWrappedObject->setRangeZoomAxes(horizontal, vertical)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::setRangeZoomFactor(QCPAxisRect* theWrappedObject, double factor) | ||||
{ | ||||
( theWrappedObject->setRangeZoomFactor(factor)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::setRangeZoomFactor(QCPAxisRect* theWrappedObject, double horizontalFactor, double verticalFactor) | ||||
{ | ||||
( theWrappedObject->setRangeZoomFactor(horizontalFactor, verticalFactor)); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::setupFullAxesBox(QCPAxisRect* theWrappedObject, bool connectRanges) | ||||
{ | ||||
( theWrappedObject->setupFullAxesBox(connectRanges)); | ||||
} | ||||
QSize PythonQtWrapper_QCPAxisRect::size(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->size()); | ||||
} | ||||
int PythonQtWrapper_QCPAxisRect::top(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->top()); | ||||
} | ||||
QPoint PythonQtWrapper_QCPAxisRect::topLeft(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->topLeft()); | ||||
} | ||||
QPoint PythonQtWrapper_QCPAxisRect::topRight(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->topRight()); | ||||
} | ||||
void PythonQtWrapper_QCPAxisRect::wheelEvent(QCPAxisRect* theWrappedObject, QWheelEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_wheelEvent(event)); | ||||
} | ||||
int PythonQtWrapper_QCPAxisRect::width(QCPAxisRect* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->width()); | ||||
} | ||||
PythonQtShell_QCPBars::~PythonQtShell_QCPBars() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCPBars::clearData() | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("clearData"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPBars::clearData(); | ||||
} | ||||
void PythonQtShell_QCPBars::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPBars::draw(painter0); | ||||
} | ||||
void PythonQtShell_QCPBars::drawLegendIcon(QCPPainter* painter0, const QRectF& rect1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("drawLegendIcon"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*" , "const QRectF&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&painter0, (void*)&rect1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPBars::drawLegendIcon(painter0, rect1); | ||||
} | ||||
double PythonQtShell_QCPBars::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectTest"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
double returnValue; | ||||
void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result); | ||||
} else { | ||||
returnValue = *((double*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPBars::selectTest(pos0, onlySelectable1, details2); | ||||
} | ||||
QCPBars* PythonQtWrapper_QCPBars::new_QCPBars(QCPAxis* keyAxis, QCPAxis* valueAxis) | ||||
{ | ||||
return new PythonQtShell_QCPBars(keyAxis, valueAxis); } | ||||
void PythonQtWrapper_QCPBars::addData(QCPBars* theWrappedObject, const QVector<double >& keys, const QVector<double >& values) | ||||
{ | ||||
( theWrappedObject->addData(keys, values)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::addData(QCPBars* theWrappedObject, double key, double value) | ||||
{ | ||||
( theWrappedObject->addData(key, value)); | ||||
} | ||||
QCPBars* PythonQtWrapper_QCPBars::barAbove(QCPBars* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->barAbove()); | ||||
} | ||||
QCPBars* PythonQtWrapper_QCPBars::barBelow(QCPBars* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->barBelow()); | ||||
} | ||||
double PythonQtWrapper_QCPBars::baseValue(QCPBars* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->baseValue()); | ||||
} | ||||
void PythonQtWrapper_QCPBars::clearData(QCPBars* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_clearData()); | ||||
} | ||||
void PythonQtWrapper_QCPBars::static_QCPBars_connectBars(QCPBars* lower, QCPBars* upper) | ||||
{ | ||||
(PythonQtPublicPromoter_QCPBars::promoted_connectBars(lower, upper)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::draw(QCPBars* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_draw(painter)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::drawLegendIcon(QCPBars* theWrappedObject, QCPPainter* painter, const QRectF& rect) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_drawLegendIcon(painter, rect)); | ||||
} | ||||
QPolygonF PythonQtWrapper_QCPBars::getBarPolygon(QCPBars* theWrappedObject, double key, double value) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_getBarPolygon(key, value)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::getPixelWidth(QCPBars* theWrappedObject, double key, double& lower, double& upper) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_getPixelWidth(key, lower, upper)); | ||||
} | ||||
double PythonQtWrapper_QCPBars::getStackedBaseValue(QCPBars* theWrappedObject, double key, bool positive) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_getStackedBaseValue(key, positive)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::moveAbove(QCPBars* theWrappedObject, QCPBars* bars) | ||||
{ | ||||
( theWrappedObject->moveAbove(bars)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::moveBelow(QCPBars* theWrappedObject, QCPBars* bars) | ||||
{ | ||||
( theWrappedObject->moveBelow(bars)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::removeData(QCPBars* theWrappedObject, double fromKey, double toKey) | ||||
{ | ||||
( theWrappedObject->removeData(fromKey, toKey)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::removeData(QCPBars* theWrappedObject, double key) | ||||
{ | ||||
( theWrappedObject->removeData(key)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::removeDataAfter(QCPBars* theWrappedObject, double key) | ||||
{ | ||||
( theWrappedObject->removeDataAfter(key)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::removeDataBefore(QCPBars* theWrappedObject, double key) | ||||
{ | ||||
( theWrappedObject->removeDataBefore(key)); | ||||
} | ||||
double PythonQtWrapper_QCPBars::selectTest(QCPBars* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::setBaseValue(QCPBars* theWrappedObject, double baseValue) | ||||
{ | ||||
( theWrappedObject->setBaseValue(baseValue)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::setData(QCPBars* theWrappedObject, const QVector<double >& key, const QVector<double >& value) | ||||
{ | ||||
( theWrappedObject->setData(key, value)); | ||||
} | ||||
void PythonQtWrapper_QCPBars::setWidth(QCPBars* theWrappedObject, double width) | ||||
{ | ||||
( theWrappedObject->setWidth(width)); | ||||
} | ||||
double PythonQtWrapper_QCPBars::width(QCPBars* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->width()); | ||||
} | ||||
PythonQtShell_QCPColorMap::~PythonQtShell_QCPColorMap() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCPColorMap::clearData() | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("clearData"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorMap::clearData(); | ||||
} | ||||
void PythonQtShell_QCPColorMap::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorMap::draw(painter0); | ||||
} | ||||
void PythonQtShell_QCPColorMap::drawLegendIcon(QCPPainter* painter0, const QRectF& rect1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("drawLegendIcon"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*" , "const QRectF&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&painter0, (void*)&rect1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorMap::drawLegendIcon(painter0, rect1); | ||||
} | ||||
double PythonQtShell_QCPColorMap::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectTest"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
double returnValue; | ||||
void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result); | ||||
} else { | ||||
returnValue = *((double*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPColorMap::selectTest(pos0, onlySelectable1, details2); | ||||
} | ||||
void PythonQtShell_QCPColorMap::updateMapImage() | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("updateMapImage"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorMap::updateMapImage(); | ||||
} | ||||
QCPColorMap* PythonQtWrapper_QCPColorMap::new_QCPColorMap(QCPAxis* keyAxis, QCPAxis* valueAxis) | ||||
{ | ||||
return new PythonQtShell_QCPColorMap(keyAxis, valueAxis); } | ||||
void PythonQtWrapper_QCPColorMap::clearData(QCPColorMap* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_clearData()); | ||||
} | ||||
QCPColorScale* PythonQtWrapper_QCPColorMap::colorScale(QCPColorMap* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->colorScale()); | ||||
} | ||||
void PythonQtWrapper_QCPColorMap::draw(QCPColorMap* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_draw(painter)); | ||||
} | ||||
void PythonQtWrapper_QCPColorMap::drawLegendIcon(QCPColorMap* theWrappedObject, QCPPainter* painter, const QRectF& rect) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_drawLegendIcon(painter, rect)); | ||||
} | ||||
bool PythonQtWrapper_QCPColorMap::interpolate(QCPColorMap* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->interpolate()); | ||||
} | ||||
void PythonQtWrapper_QCPColorMap::rescaleDataRange(QCPColorMap* theWrappedObject, bool recalculateDataBounds) | ||||
{ | ||||
( theWrappedObject->rescaleDataRange(recalculateDataBounds)); | ||||
} | ||||
double PythonQtWrapper_QCPColorMap::selectTest(QCPColorMap* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details)); | ||||
} | ||||
void PythonQtWrapper_QCPColorMap::setColorScale(QCPColorMap* theWrappedObject, QCPColorScale* colorScale) | ||||
{ | ||||
( theWrappedObject->setColorScale(colorScale)); | ||||
} | ||||
void PythonQtWrapper_QCPColorMap::setInterpolate(QCPColorMap* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setInterpolate(enabled)); | ||||
} | ||||
void PythonQtWrapper_QCPColorMap::setTightBoundary(QCPColorMap* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setTightBoundary(enabled)); | ||||
} | ||||
bool PythonQtWrapper_QCPColorMap::tightBoundary(QCPColorMap* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->tightBoundary()); | ||||
} | ||||
void PythonQtWrapper_QCPColorMap::updateLegendIcon(QCPColorMap* theWrappedObject, Qt::TransformationMode transformMode, const QSize& thumbSize) | ||||
{ | ||||
( theWrappedObject->updateLegendIcon(transformMode, thumbSize)); | ||||
} | ||||
void PythonQtWrapper_QCPColorMap::updateMapImage(QCPColorMap* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_updateMapImage()); | ||||
} | ||||
PythonQtShell_QCPColorScale::~PythonQtShell_QCPColorScale() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCPColorScale::applyDefaultAntialiasingHint(QCPPainter* painter0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::applyDefaultAntialiasingHint(painter0); | ||||
} | ||||
void PythonQtShell_QCPColorScale::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::childEvent(arg__1); | ||||
} | ||||
QRect PythonQtShell_QCPColorScale::clipRect() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("clipRect"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QRect"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QRect 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("clipRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPColorScale::clipRect(); | ||||
} | ||||
void PythonQtShell_QCPColorScale::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPColorScale::deselectEvent(bool* selectionStateChanged0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("deselectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&selectionStateChanged0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::deselectEvent(selectionStateChanged0); | ||||
} | ||||
void PythonQtShell_QCPColorScale::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::draw(painter0); | ||||
} | ||||
QList<QCPLayoutElement* > PythonQtShell_QCPColorScale::elements(bool recursive0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("elements"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QList<QCPLayoutElement* > returnValue; | ||||
void* args[2] = {NULL, (void*)&recursive0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QList<QCPLayoutElement* >*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPColorScale::elements(recursive0); | ||||
} | ||||
bool PythonQtShell_QCPColorScale::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPColorScale::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QCPColorScale::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPColorScale::eventFilter(arg__1, arg__2); | ||||
} | ||||
QSize PythonQtShell_QCPColorScale::maximumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("maximumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("maximumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPColorScale::maximumSizeHint(); | ||||
} | ||||
QSize PythonQtShell_QCPColorScale::minimumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("minimumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("minimumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPColorScale::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QCPColorScale::mouseDoubleClickEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseDoubleClickEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::mouseDoubleClickEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPColorScale::mouseMoveEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseMoveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::mouseMoveEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPColorScale::mousePressEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mousePressEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::mousePressEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPColorScale::mouseReleaseEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseReleaseEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::mouseReleaseEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPColorScale::parentPlotInitialized(QCustomPlot* parentPlot0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("parentPlotInitialized"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCustomPlot*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&parentPlot0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::parentPlotInitialized(parentPlot0); | ||||
} | ||||
void PythonQtShell_QCPColorScale::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::selectEvent(event0, additive1, details2, selectionStateChanged3); | ||||
} | ||||
double PythonQtShell_QCPColorScale::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectTest"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
double returnValue; | ||||
void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result); | ||||
} else { | ||||
returnValue = *((double*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPColorScale::selectTest(pos0, onlySelectable1, details2); | ||||
} | ||||
void PythonQtShell_QCPColorScale::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPColorScale::wheelEvent(QWheelEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("wheelEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPColorScale::wheelEvent(event0); | ||||
} | ||||
QCPColorScale* PythonQtWrapper_QCPColorScale::new_QCPColorScale(QCustomPlot* parentPlot) | ||||
{ | ||||
return new PythonQtShell_QCPColorScale(parentPlot); } | ||||
void PythonQtWrapper_QCPColorScale::applyDefaultAntialiasingHint(QCPColorScale* theWrappedObject, QCPPainter* painter) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter)); | ||||
} | ||||
QCPAxis* PythonQtWrapper_QCPColorScale::axis(QCPColorScale* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->axis()); | ||||
} | ||||
int PythonQtWrapper_QCPColorScale::barWidth(QCPColorScale* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->barWidth()); | ||||
} | ||||
QList<QCPColorMap* > PythonQtWrapper_QCPColorScale::colorMaps(QCPColorScale* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->colorMaps()); | ||||
} | ||||
QString PythonQtWrapper_QCPColorScale::label(QCPColorScale* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->label()); | ||||
} | ||||
void PythonQtWrapper_QCPColorScale::mouseMoveEvent(QCPColorScale* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_mouseMoveEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QCPColorScale::mousePressEvent(QCPColorScale* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_mousePressEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QCPColorScale::mouseReleaseEvent(QCPColorScale* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_mouseReleaseEvent(event)); | ||||
} | ||||
bool PythonQtWrapper_QCPColorScale::rangeDrag(QCPColorScale* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rangeDrag()); | ||||
} | ||||
bool PythonQtWrapper_QCPColorScale::rangeZoom(QCPColorScale* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rangeZoom()); | ||||
} | ||||
void PythonQtWrapper_QCPColorScale::rescaleDataRange(QCPColorScale* theWrappedObject, bool onlyVisibleMaps) | ||||
{ | ||||
( theWrappedObject->rescaleDataRange(onlyVisibleMaps)); | ||||
} | ||||
void PythonQtWrapper_QCPColorScale::setBarWidth(QCPColorScale* theWrappedObject, int width) | ||||
{ | ||||
( theWrappedObject->setBarWidth(width)); | ||||
} | ||||
void PythonQtWrapper_QCPColorScale::setLabel(QCPColorScale* theWrappedObject, const QString& str) | ||||
{ | ||||
( theWrappedObject->setLabel(str)); | ||||
} | ||||
void PythonQtWrapper_QCPColorScale::setRangeDrag(QCPColorScale* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setRangeDrag(enabled)); | ||||
} | ||||
void PythonQtWrapper_QCPColorScale::setRangeZoom(QCPColorScale* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setRangeZoom(enabled)); | ||||
} | ||||
void PythonQtWrapper_QCPColorScale::wheelEvent(QCPColorScale* theWrappedObject, QWheelEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_wheelEvent(event)); | ||||
} | ||||
PythonQtShell_QCPGraph::~PythonQtShell_QCPGraph() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCPGraph::clearData() | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("clearData"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPGraph::clearData(); | ||||
} | ||||
void PythonQtShell_QCPGraph::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPGraph::draw(painter0); | ||||
} | ||||
void PythonQtShell_QCPGraph::drawFill(QCPPainter* painter0, QVector<QPointF >* lineData1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("drawFill"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*" , "QVector<QPointF >*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&painter0, (void*)&lineData1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPGraph::drawFill(painter0, lineData1); | ||||
} | ||||
void PythonQtShell_QCPGraph::drawImpulsePlot(QCPPainter* painter0, QVector<QPointF >* lineData1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("drawImpulsePlot"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*" , "QVector<QPointF >*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&painter0, (void*)&lineData1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPGraph::drawImpulsePlot(painter0, lineData1); | ||||
} | ||||
void PythonQtShell_QCPGraph::drawLegendIcon(QCPPainter* painter0, const QRectF& rect1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("drawLegendIcon"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*" , "const QRectF&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&painter0, (void*)&rect1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPGraph::drawLegendIcon(painter0, rect1); | ||||
} | ||||
void PythonQtShell_QCPGraph::drawLinePlot(QCPPainter* painter0, QVector<QPointF >* lineData1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("drawLinePlot"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*" , "QVector<QPointF >*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&painter0, (void*)&lineData1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPGraph::drawLinePlot(painter0, lineData1); | ||||
} | ||||
double PythonQtShell_QCPGraph::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectTest"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
double returnValue; | ||||
void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result); | ||||
} else { | ||||
returnValue = *((double*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPGraph::selectTest(pos0, onlySelectable1, details2); | ||||
} | ||||
QCPGraph* PythonQtWrapper_QCPGraph::new_QCPGraph(QCPAxis* keyAxis, QCPAxis* valueAxis) | ||||
{ | ||||
return new PythonQtShell_QCPGraph(keyAxis, valueAxis); } | ||||
bool PythonQtWrapper_QCPGraph::adaptiveSampling(QCPGraph* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->adaptiveSampling()); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::addData(QCPGraph* theWrappedObject, const QVector<double >& keys, const QVector<double >& values) | ||||
{ | ||||
( theWrappedObject->addData(keys, values)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::addData(QCPGraph* theWrappedObject, double key, double value) | ||||
{ | ||||
( theWrappedObject->addData(key, value)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::addFillBasePoints(QCPGraph* theWrappedObject, QVector<QPointF >* lineData) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_addFillBasePoints(lineData)); | ||||
} | ||||
QCPGraph* PythonQtWrapper_QCPGraph::channelFillGraph(QCPGraph* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->channelFillGraph()); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::clearData(QCPGraph* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_clearData()); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::draw(QCPGraph* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_draw(painter)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::drawFill(QCPGraph* theWrappedObject, QCPPainter* painter, QVector<QPointF >* lineData) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawFill(painter, lineData)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::drawImpulsePlot(QCPGraph* theWrappedObject, QCPPainter* painter, QVector<QPointF >* lineData) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawImpulsePlot(painter, lineData)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::drawLegendIcon(QCPGraph* theWrappedObject, QCPPainter* painter, const QRectF& rect) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawLegendIcon(painter, rect)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::drawLinePlot(QCPGraph* theWrappedObject, QCPPainter* painter, QVector<QPointF >* lineData) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawLinePlot(painter, lineData)); | ||||
} | ||||
double PythonQtWrapper_QCPGraph::errorBarSize(QCPGraph* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->errorBarSize()); | ||||
} | ||||
bool PythonQtWrapper_QCPGraph::errorBarSkipSymbol(QCPGraph* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->errorBarSkipSymbol()); | ||||
} | ||||
QPen PythonQtWrapper_QCPGraph::errorPen(QCPGraph* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->errorPen()); | ||||
} | ||||
int PythonQtWrapper_QCPGraph::findIndexAboveX(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double x) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexAboveX(data, x)); | ||||
} | ||||
int PythonQtWrapper_QCPGraph::findIndexAboveY(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double y) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexAboveY(data, y)); | ||||
} | ||||
int PythonQtWrapper_QCPGraph::findIndexBelowX(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double x) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexBelowX(data, x)); | ||||
} | ||||
int PythonQtWrapper_QCPGraph::findIndexBelowY(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double y) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexBelowY(data, y)); | ||||
} | ||||
const QPolygonF PythonQtWrapper_QCPGraph::getChannelFillPolygon(QCPGraph* theWrappedObject, const QVector<QPointF >* lineData) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_getChannelFillPolygon(lineData)); | ||||
} | ||||
QPointF PythonQtWrapper_QCPGraph::lowerFillBasePoint(QCPGraph* theWrappedObject, double lowerKey) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_lowerFillBasePoint(lowerKey)); | ||||
} | ||||
double PythonQtWrapper_QCPGraph::pointDistance(QCPGraph* theWrappedObject, const QPointF& pixelPoint) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_pointDistance(pixelPoint)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::removeData(QCPGraph* theWrappedObject, double fromKey, double toKey) | ||||
{ | ||||
( theWrappedObject->removeData(fromKey, toKey)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::removeData(QCPGraph* theWrappedObject, double key) | ||||
{ | ||||
( theWrappedObject->removeData(key)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::removeDataAfter(QCPGraph* theWrappedObject, double key) | ||||
{ | ||||
( theWrappedObject->removeDataAfter(key)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::removeDataBefore(QCPGraph* theWrappedObject, double key) | ||||
{ | ||||
( theWrappedObject->removeDataBefore(key)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::removeFillBasePoints(QCPGraph* theWrappedObject, QVector<QPointF >* lineData) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_removeFillBasePoints(lineData)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::rescaleAxes(QCPGraph* theWrappedObject, bool onlyEnlarge, bool includeErrorBars) const | ||||
{ | ||||
( theWrappedObject->rescaleAxes(onlyEnlarge, includeErrorBars)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::rescaleKeyAxis(QCPGraph* theWrappedObject, bool onlyEnlarge, bool includeErrorBars) const | ||||
{ | ||||
( theWrappedObject->rescaleKeyAxis(onlyEnlarge, includeErrorBars)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::rescaleValueAxis(QCPGraph* theWrappedObject, bool onlyEnlarge, bool includeErrorBars) const | ||||
{ | ||||
( theWrappedObject->rescaleValueAxis(onlyEnlarge, includeErrorBars)); | ||||
} | ||||
double PythonQtWrapper_QCPGraph::selectTest(QCPGraph* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setAdaptiveSampling(QCPGraph* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setAdaptiveSampling(enabled)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setChannelFillGraph(QCPGraph* theWrappedObject, QCPGraph* targetGraph) | ||||
{ | ||||
( theWrappedObject->setChannelFillGraph(targetGraph)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setData(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value) | ||||
{ | ||||
( theWrappedObject->setData(key, value)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setDataBothError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyError, const QVector<double >& valueError) | ||||
{ | ||||
( theWrappedObject->setDataBothError(key, value, keyError, valueError)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setDataBothError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyErrorMinus, const QVector<double >& keyErrorPlus, const QVector<double >& valueErrorMinus, const QVector<double >& valueErrorPlus) | ||||
{ | ||||
( theWrappedObject->setDataBothError(key, value, keyErrorMinus, keyErrorPlus, valueErrorMinus, valueErrorPlus)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setDataKeyError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyError) | ||||
{ | ||||
( theWrappedObject->setDataKeyError(key, value, keyError)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setDataKeyError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyErrorMinus, const QVector<double >& keyErrorPlus) | ||||
{ | ||||
( theWrappedObject->setDataKeyError(key, value, keyErrorMinus, keyErrorPlus)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setDataValueError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& valueError) | ||||
{ | ||||
( theWrappedObject->setDataValueError(key, value, valueError)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setDataValueError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& valueErrorMinus, const QVector<double >& valueErrorPlus) | ||||
{ | ||||
( theWrappedObject->setDataValueError(key, value, valueErrorMinus, valueErrorPlus)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setErrorBarSize(QCPGraph* theWrappedObject, double size) | ||||
{ | ||||
( theWrappedObject->setErrorBarSize(size)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setErrorBarSkipSymbol(QCPGraph* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setErrorBarSkipSymbol(enabled)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setErrorPen(QCPGraph* theWrappedObject, const QPen& pen) | ||||
{ | ||||
( theWrappedObject->setErrorPen(pen)); | ||||
} | ||||
void PythonQtWrapper_QCPGraph::setUseFastVectors(QCPGraph* theWrappedObject, bool useFastVectors) | ||||
{ | ||||
( theWrappedObject->setUseFastVectors(useFastVectors)); | ||||
} | ||||
QPointF PythonQtWrapper_QCPGraph::upperFillBasePoint(QCPGraph* theWrappedObject, double upperKey) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_upperFillBasePoint(upperKey)); | ||||
} | ||||
bool PythonQtWrapper_QCPGraph::useFastVectors(QCPGraph* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->useFastVectors()); | ||||
} | ||||
PythonQtShell_QCPItemPosition::~PythonQtShell_QCPItemPosition() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QPointF PythonQtShell_QCPItemPosition::pixelPoint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("pixelPoint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QPointF"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPointF 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("pixelPoint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPointF*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPItemPosition::pixelPoint(); | ||||
} | ||||
QCPItemPosition* PythonQtShell_QCPItemPosition::toQCPItemPosition() | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("toQCPItemPosition"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QCPItemPosition*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QCPItemPosition* 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("toQCPItemPosition", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QCPItemPosition**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPItemPosition::toQCPItemPosition(); | ||||
} | ||||
QCPItemPosition* PythonQtWrapper_QCPItemPosition::new_QCPItemPosition(QCustomPlot* parentPlot, QCPAbstractItem* parentItem, const QString name) | ||||
{ | ||||
return new PythonQtShell_QCPItemPosition(parentPlot, parentItem, name); } | ||||
QCPAxisRect* PythonQtWrapper_QCPItemPosition::axisRect(QCPItemPosition* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->axisRect()); | ||||
} | ||||
QPointF PythonQtWrapper_QCPItemPosition::coords(QCPItemPosition* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->coords()); | ||||
} | ||||
double PythonQtWrapper_QCPItemPosition::key(QCPItemPosition* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->key()); | ||||
} | ||||
QCPAxis* PythonQtWrapper_QCPItemPosition::keyAxis(QCPItemPosition* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->keyAxis()); | ||||
} | ||||
QPointF PythonQtWrapper_QCPItemPosition::pixelPoint(QCPItemPosition* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPItemPosition*)theWrappedObject)->promoted_pixelPoint()); | ||||
} | ||||
void PythonQtWrapper_QCPItemPosition::setAxes(QCPItemPosition* theWrappedObject, QCPAxis* keyAxis, QCPAxis* valueAxis) | ||||
{ | ||||
( theWrappedObject->setAxes(keyAxis, valueAxis)); | ||||
} | ||||
void PythonQtWrapper_QCPItemPosition::setAxisRect(QCPItemPosition* theWrappedObject, QCPAxisRect* axisRect) | ||||
{ | ||||
( theWrappedObject->setAxisRect(axisRect)); | ||||
} | ||||
void PythonQtWrapper_QCPItemPosition::setCoords(QCPItemPosition* theWrappedObject, const QPointF& coords) | ||||
{ | ||||
( theWrappedObject->setCoords(coords)); | ||||
} | ||||
void PythonQtWrapper_QCPItemPosition::setCoords(QCPItemPosition* theWrappedObject, double key, double value) | ||||
{ | ||||
( theWrappedObject->setCoords(key, value)); | ||||
} | ||||
void PythonQtWrapper_QCPItemPosition::setPixelPoint(QCPItemPosition* theWrappedObject, const QPointF& pixelPoint) | ||||
{ | ||||
( theWrappedObject->setPixelPoint(pixelPoint)); | ||||
} | ||||
QCPItemPosition* PythonQtWrapper_QCPItemPosition::toQCPItemPosition(QCPItemPosition* theWrappedObject) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPItemPosition*)theWrappedObject)->promoted_toQCPItemPosition()); | ||||
} | ||||
double PythonQtWrapper_QCPItemPosition::value(QCPItemPosition* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->value()); | ||||
} | ||||
QCPAxis* PythonQtWrapper_QCPItemPosition::valueAxis(QCPItemPosition* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->valueAxis()); | ||||
} | ||||
PythonQtShell_QCPLayer::~PythonQtShell_QCPLayer() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCPLayer::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayer::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPLayer::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayer::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QCPLayer::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayer::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QCPLayer::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayer::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QCPLayer::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayer::timerEvent(arg__1); | ||||
} | ||||
QCPLayer* PythonQtWrapper_QCPLayer::new_QCPLayer(QCustomPlot* parentPlot, const QString& layerName) | ||||
{ | ||||
return new PythonQtShell_QCPLayer(parentPlot, layerName); } | ||||
void PythonQtWrapper_QCPLayer::addChild(QCPLayer* theWrappedObject, QCPLayerable* layerable, bool prepend) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayer*)theWrappedObject)->promoted_addChild(layerable, prepend)); | ||||
} | ||||
QList<QCPLayerable* > PythonQtWrapper_QCPLayer::children(QCPLayer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->children()); | ||||
} | ||||
int PythonQtWrapper_QCPLayer::index(QCPLayer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->index()); | ||||
} | ||||
QString PythonQtWrapper_QCPLayer::name(QCPLayer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->name()); | ||||
} | ||||
QCustomPlot* PythonQtWrapper_QCPLayer::parentPlot(QCPLayer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->parentPlot()); | ||||
} | ||||
void PythonQtWrapper_QCPLayer::removeChild(QCPLayer* theWrappedObject, QCPLayerable* layerable) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayer*)theWrappedObject)->promoted_removeChild(layerable)); | ||||
} | ||||
void PythonQtWrapper_QCPLayer::setVisible(QCPLayer* theWrappedObject, bool visible) | ||||
{ | ||||
( theWrappedObject->setVisible(visible)); | ||||
} | ||||
bool PythonQtWrapper_QCPLayer::visible(QCPLayer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->visible()); | ||||
} | ||||
PythonQtShell_QCPLayerable::~PythonQtShell_QCPLayerable() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCPLayerable::applyDefaultAntialiasingHint(QCPPainter* painter0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
} | ||||
void PythonQtShell_QCPLayerable::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayerable::childEvent(arg__1); | ||||
} | ||||
QRect PythonQtShell_QCPLayerable::clipRect() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("clipRect"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QRect"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QRect 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("clipRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayerable::clipRect(); | ||||
} | ||||
void PythonQtShell_QCPLayerable::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayerable::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPLayerable::deselectEvent(bool* selectionStateChanged0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("deselectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&selectionStateChanged0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayerable::deselectEvent(selectionStateChanged0); | ||||
} | ||||
void PythonQtShell_QCPLayerable::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
} | ||||
bool PythonQtShell_QCPLayerable::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayerable::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QCPLayerable::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayerable::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QCPLayerable::parentPlotInitialized(QCustomPlot* parentPlot0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("parentPlotInitialized"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCustomPlot*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&parentPlot0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayerable::parentPlotInitialized(parentPlot0); | ||||
} | ||||
void PythonQtShell_QCPLayerable::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayerable::selectEvent(event0, additive1, details2, selectionStateChanged3); | ||||
} | ||||
double PythonQtShell_QCPLayerable::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectTest"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
double returnValue; | ||||
void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result); | ||||
} else { | ||||
returnValue = *((double*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayerable::selectTest(pos0, onlySelectable1, details2); | ||||
} | ||||
void PythonQtShell_QCPLayerable::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayerable::timerEvent(arg__1); | ||||
} | ||||
QCPLayerable* PythonQtWrapper_QCPLayerable::new_QCPLayerable(QCustomPlot* plot, QString targetLayer, QCPLayerable* parentLayerable) | ||||
{ | ||||
return new PythonQtShell_QCPLayerable(plot, targetLayer, parentLayerable); } | ||||
bool PythonQtWrapper_QCPLayerable::antialiased(QCPLayerable* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->antialiased()); | ||||
} | ||||
void PythonQtWrapper_QCPLayerable::applyDefaultAntialiasingHint(QCPLayerable* theWrappedObject, QCPPainter* painter) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter)); | ||||
} | ||||
QRect PythonQtWrapper_QCPLayerable::clipRect(QCPLayerable* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_clipRect()); | ||||
} | ||||
void PythonQtWrapper_QCPLayerable::deselectEvent(QCPLayerable* theWrappedObject, bool* selectionStateChanged) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged)); | ||||
} | ||||
void PythonQtWrapper_QCPLayerable::draw(QCPLayerable* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_draw(painter)); | ||||
} | ||||
void PythonQtWrapper_QCPLayerable::initializeParentPlot(QCPLayerable* theWrappedObject, QCustomPlot* parentPlot) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_initializeParentPlot(parentPlot)); | ||||
} | ||||
QCPLayer* PythonQtWrapper_QCPLayerable::layer(QCPLayerable* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->layer()); | ||||
} | ||||
bool PythonQtWrapper_QCPLayerable::moveToLayer(QCPLayerable* theWrappedObject, QCPLayer* layer, bool prepend) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_moveToLayer(layer, prepend)); | ||||
} | ||||
QCPLayerable* PythonQtWrapper_QCPLayerable::parentLayerable(QCPLayerable* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->parentLayerable()); | ||||
} | ||||
QCustomPlot* PythonQtWrapper_QCPLayerable::parentPlot(QCPLayerable* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->parentPlot()); | ||||
} | ||||
void PythonQtWrapper_QCPLayerable::parentPlotInitialized(QCPLayerable* theWrappedObject, QCustomPlot* parentPlot) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_parentPlotInitialized(parentPlot)); | ||||
} | ||||
bool PythonQtWrapper_QCPLayerable::realVisibility(QCPLayerable* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->realVisibility()); | ||||
} | ||||
void PythonQtWrapper_QCPLayerable::selectEvent(QCPLayerable* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged)); | ||||
} | ||||
double PythonQtWrapper_QCPLayerable::selectTest(QCPLayerable* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details)); | ||||
} | ||||
void PythonQtWrapper_QCPLayerable::setAntialiased(QCPLayerable* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setAntialiased(enabled)); | ||||
} | ||||
bool PythonQtWrapper_QCPLayerable::setLayer(QCPLayerable* theWrappedObject, QCPLayer* layer) | ||||
{ | ||||
return ( theWrappedObject->setLayer(layer)); | ||||
} | ||||
bool PythonQtWrapper_QCPLayerable::setLayer(QCPLayerable* theWrappedObject, const QString& layerName) | ||||
{ | ||||
return ( theWrappedObject->setLayer(layerName)); | ||||
} | ||||
void PythonQtWrapper_QCPLayerable::setParentLayerable(QCPLayerable* theWrappedObject, QCPLayerable* parentLayerable) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_setParentLayerable(parentLayerable)); | ||||
} | ||||
void PythonQtWrapper_QCPLayerable::setVisible(QCPLayerable* theWrappedObject, bool on) | ||||
{ | ||||
( theWrappedObject->setVisible(on)); | ||||
} | ||||
bool PythonQtWrapper_QCPLayerable::visible(QCPLayerable* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->visible()); | ||||
} | ||||
PythonQtShell_QCPLayout::~PythonQtShell_QCPLayout() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCPLayout::applyDefaultAntialiasingHint(QCPPainter* painter0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::applyDefaultAntialiasingHint(painter0); | ||||
} | ||||
void PythonQtShell_QCPLayout::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::childEvent(arg__1); | ||||
} | ||||
QRect PythonQtShell_QCPLayout::clipRect() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("clipRect"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QRect"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QRect 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("clipRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayout::clipRect(); | ||||
} | ||||
void PythonQtShell_QCPLayout::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPLayout::deselectEvent(bool* selectionStateChanged0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("deselectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&selectionStateChanged0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::deselectEvent(selectionStateChanged0); | ||||
} | ||||
void PythonQtShell_QCPLayout::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::draw(painter0); | ||||
} | ||||
QCPLayoutElement* PythonQtShell_QCPLayout::elementAt(int index0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("elementAt"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QCPLayoutElement*" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QCPLayoutElement* returnValue; | ||||
void* args[2] = {NULL, (void*)&index0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("elementAt", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QCPLayoutElement**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return 0; | ||||
} | ||||
int PythonQtShell_QCPLayout::elementCount() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("elementCount"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("elementCount", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return int(); | ||||
} | ||||
QList<QCPLayoutElement* > PythonQtShell_QCPLayout::elements(bool recursive0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("elements"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QList<QCPLayoutElement* > returnValue; | ||||
void* args[2] = {NULL, (void*)&recursive0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QList<QCPLayoutElement* >*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayout::elements(recursive0); | ||||
} | ||||
bool PythonQtShell_QCPLayout::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayout::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QCPLayout::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayout::eventFilter(arg__1, arg__2); | ||||
} | ||||
QSize PythonQtShell_QCPLayout::maximumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("maximumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("maximumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayout::maximumSizeHint(); | ||||
} | ||||
QSize PythonQtShell_QCPLayout::minimumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("minimumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("minimumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayout::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QCPLayout::mouseDoubleClickEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseDoubleClickEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::mouseDoubleClickEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPLayout::mouseMoveEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseMoveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::mouseMoveEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPLayout::mousePressEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mousePressEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::mousePressEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPLayout::mouseReleaseEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseReleaseEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::mouseReleaseEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPLayout::parentPlotInitialized(QCustomPlot* parentPlot0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("parentPlotInitialized"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCustomPlot*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&parentPlot0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::parentPlotInitialized(parentPlot0); | ||||
} | ||||
void PythonQtShell_QCPLayout::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::selectEvent(event0, additive1, details2, selectionStateChanged3); | ||||
} | ||||
double PythonQtShell_QCPLayout::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectTest"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
double returnValue; | ||||
void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result); | ||||
} else { | ||||
returnValue = *((double*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayout::selectTest(pos0, onlySelectable1, details2); | ||||
} | ||||
void PythonQtShell_QCPLayout::simplify() | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("simplify"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::simplify(); | ||||
} | ||||
bool PythonQtShell_QCPLayout::take(QCPLayoutElement* element0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("take"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"bool" , "QCPLayoutElement*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&element0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("take", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return bool(); | ||||
} | ||||
QCPLayoutElement* PythonQtShell_QCPLayout::takeAt(int index0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("takeAt"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QCPLayoutElement*" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QCPLayoutElement* returnValue; | ||||
void* args[2] = {NULL, (void*)&index0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("takeAt", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QCPLayoutElement**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return 0; | ||||
} | ||||
void PythonQtShell_QCPLayout::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPLayout::updateLayout() | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("updateLayout"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::updateLayout(); | ||||
} | ||||
void PythonQtShell_QCPLayout::wheelEvent(QWheelEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("wheelEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayout::wheelEvent(event0); | ||||
} | ||||
QCPLayout* PythonQtWrapper_QCPLayout::new_QCPLayout() | ||||
{ | ||||
return new PythonQtShell_QCPLayout(); } | ||||
void PythonQtWrapper_QCPLayout::adoptElement(QCPLayout* theWrappedObject, QCPLayoutElement* el) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_adoptElement(el)); | ||||
} | ||||
void PythonQtWrapper_QCPLayout::clear(QCPLayout* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->clear()); | ||||
} | ||||
QCPLayoutElement* PythonQtWrapper_QCPLayout::elementAt(QCPLayout* theWrappedObject, int index) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_elementAt(index)); | ||||
} | ||||
int PythonQtWrapper_QCPLayout::elementCount(QCPLayout* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_elementCount()); | ||||
} | ||||
QList<QCPLayoutElement* > PythonQtWrapper_QCPLayout::elements(QCPLayout* theWrappedObject, bool recursive) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_elements(recursive)); | ||||
} | ||||
QVector<int > PythonQtWrapper_QCPLayout::getSectionSizes(QCPLayout* theWrappedObject, QVector<int > maxSizes, QVector<int > minSizes, QVector<double > stretchFactors, int totalSize) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_getSectionSizes(maxSizes, minSizes, stretchFactors, totalSize)); | ||||
} | ||||
void PythonQtWrapper_QCPLayout::releaseElement(QCPLayout* theWrappedObject, QCPLayoutElement* el) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_releaseElement(el)); | ||||
} | ||||
bool PythonQtWrapper_QCPLayout::remove(QCPLayout* theWrappedObject, QCPLayoutElement* element) | ||||
{ | ||||
return ( theWrappedObject->remove(element)); | ||||
} | ||||
bool PythonQtWrapper_QCPLayout::removeAt(QCPLayout* theWrappedObject, int index) | ||||
{ | ||||
return ( theWrappedObject->removeAt(index)); | ||||
} | ||||
void PythonQtWrapper_QCPLayout::simplify(QCPLayout* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_simplify()); | ||||
} | ||||
void PythonQtWrapper_QCPLayout::sizeConstraintsChanged(QCPLayout* theWrappedObject) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_sizeConstraintsChanged()); | ||||
} | ||||
bool PythonQtWrapper_QCPLayout::take(QCPLayout* theWrappedObject, QCPLayoutElement* element) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_take(element)); | ||||
} | ||||
QCPLayoutElement* PythonQtWrapper_QCPLayout::takeAt(QCPLayout* theWrappedObject, int index) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_takeAt(index)); | ||||
} | ||||
void PythonQtWrapper_QCPLayout::updateLayout(QCPLayout* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_updateLayout()); | ||||
} | ||||
PythonQtShell_QCPLayoutElement::~PythonQtShell_QCPLayoutElement() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::applyDefaultAntialiasingHint(QCPPainter* painter0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::applyDefaultAntialiasingHint(painter0); | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::childEvent(arg__1); | ||||
} | ||||
QRect PythonQtShell_QCPLayoutElement::clipRect() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("clipRect"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QRect"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QRect 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("clipRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayoutElement::clipRect(); | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::deselectEvent(bool* selectionStateChanged0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("deselectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&selectionStateChanged0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::deselectEvent(selectionStateChanged0); | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::draw(painter0); | ||||
} | ||||
QList<QCPLayoutElement* > PythonQtShell_QCPLayoutElement::elements(bool recursive0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("elements"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QList<QCPLayoutElement* > returnValue; | ||||
void* args[2] = {NULL, (void*)&recursive0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QList<QCPLayoutElement* >*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayoutElement::elements(recursive0); | ||||
} | ||||
bool PythonQtShell_QCPLayoutElement::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayoutElement::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QCPLayoutElement::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayoutElement::eventFilter(arg__1, arg__2); | ||||
} | ||||
QSize PythonQtShell_QCPLayoutElement::maximumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("maximumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("maximumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayoutElement::maximumSizeHint(); | ||||
} | ||||
QSize PythonQtShell_QCPLayoutElement::minimumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("minimumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("minimumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayoutElement::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::mouseDoubleClickEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseDoubleClickEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::mouseDoubleClickEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::mouseMoveEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseMoveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::mouseMoveEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::mousePressEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mousePressEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::mousePressEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::mouseReleaseEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseReleaseEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::mouseReleaseEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::parentPlotInitialized(QCustomPlot* parentPlot0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("parentPlotInitialized"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCustomPlot*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&parentPlot0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::parentPlotInitialized(parentPlot0); | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::selectEvent(event0, additive1, details2, selectionStateChanged3); | ||||
} | ||||
double PythonQtShell_QCPLayoutElement::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectTest"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
double returnValue; | ||||
void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result); | ||||
} else { | ||||
returnValue = *((double*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLayoutElement::selectTest(pos0, onlySelectable1, details2); | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPLayoutElement::wheelEvent(QWheelEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("wheelEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLayoutElement::wheelEvent(event0); | ||||
} | ||||
QCPLayoutElement* PythonQtWrapper_QCPLayoutElement::new_QCPLayoutElement(QCustomPlot* parentPlot) | ||||
{ | ||||
return new PythonQtShell_QCPLayoutElement(parentPlot); } | ||||
void PythonQtWrapper_QCPLayoutElement::applyDefaultAntialiasingHint(QCPLayoutElement* theWrappedObject, QCPPainter* painter) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter)); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::draw(QCPLayoutElement* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_draw(painter)); | ||||
} | ||||
QList<QCPLayoutElement* > PythonQtWrapper_QCPLayoutElement::elements(QCPLayoutElement* theWrappedObject, bool recursive) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_elements(recursive)); | ||||
} | ||||
QCPLayout* PythonQtWrapper_QCPLayoutElement::layout(QCPLayoutElement* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->layout()); | ||||
} | ||||
QMargins PythonQtWrapper_QCPLayoutElement::margins(QCPLayoutElement* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->margins()); | ||||
} | ||||
QSize PythonQtWrapper_QCPLayoutElement::maximumSize(QCPLayoutElement* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->maximumSize()); | ||||
} | ||||
QSize PythonQtWrapper_QCPLayoutElement::maximumSizeHint(QCPLayoutElement* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_maximumSizeHint()); | ||||
} | ||||
QMargins PythonQtWrapper_QCPLayoutElement::minimumMargins(QCPLayoutElement* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->minimumMargins()); | ||||
} | ||||
QSize PythonQtWrapper_QCPLayoutElement::minimumSize(QCPLayoutElement* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->minimumSize()); | ||||
} | ||||
QSize PythonQtWrapper_QCPLayoutElement::minimumSizeHint(QCPLayoutElement* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_minimumSizeHint()); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::mouseDoubleClickEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_mouseDoubleClickEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::mouseMoveEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_mouseMoveEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::mousePressEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_mousePressEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::mouseReleaseEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_mouseReleaseEvent(event)); | ||||
} | ||||
QRect PythonQtWrapper_QCPLayoutElement::outerRect(QCPLayoutElement* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->outerRect()); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::parentPlotInitialized(QCPLayoutElement* theWrappedObject, QCustomPlot* parentPlot) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_parentPlotInitialized(parentPlot)); | ||||
} | ||||
QRect PythonQtWrapper_QCPLayoutElement::rect(QCPLayoutElement* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rect()); | ||||
} | ||||
double PythonQtWrapper_QCPLayoutElement::selectTest(QCPLayoutElement* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details)); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::setMargins(QCPLayoutElement* theWrappedObject, const QMargins& margins) | ||||
{ | ||||
( theWrappedObject->setMargins(margins)); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::setMaximumSize(QCPLayoutElement* theWrappedObject, const QSize& size) | ||||
{ | ||||
( theWrappedObject->setMaximumSize(size)); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::setMaximumSize(QCPLayoutElement* theWrappedObject, int width, int height) | ||||
{ | ||||
( theWrappedObject->setMaximumSize(width, height)); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::setMinimumMargins(QCPLayoutElement* theWrappedObject, const QMargins& margins) | ||||
{ | ||||
( theWrappedObject->setMinimumMargins(margins)); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::setMinimumSize(QCPLayoutElement* theWrappedObject, const QSize& size) | ||||
{ | ||||
( theWrappedObject->setMinimumSize(size)); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::setMinimumSize(QCPLayoutElement* theWrappedObject, int width, int height) | ||||
{ | ||||
( theWrappedObject->setMinimumSize(width, height)); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::setOuterRect(QCPLayoutElement* theWrappedObject, const QRect& rect) | ||||
{ | ||||
( theWrappedObject->setOuterRect(rect)); | ||||
} | ||||
void PythonQtWrapper_QCPLayoutElement::wheelEvent(QCPLayoutElement* theWrappedObject, QWheelEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_wheelEvent(event)); | ||||
} | ||||
PythonQtShell_QCPLegend::~PythonQtShell_QCPLegend() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCPLegend::applyDefaultAntialiasingHint(QCPPainter* painter0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLegend::applyDefaultAntialiasingHint(painter0); | ||||
} | ||||
void PythonQtShell_QCPLegend::deselectEvent(bool* selectionStateChanged0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("deselectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&selectionStateChanged0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLegend::deselectEvent(selectionStateChanged0); | ||||
} | ||||
void PythonQtShell_QCPLegend::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLegend::draw(painter0); | ||||
} | ||||
void PythonQtShell_QCPLegend::parentPlotInitialized(QCustomPlot* parentPlot0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("parentPlotInitialized"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCustomPlot*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&parentPlot0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLegend::parentPlotInitialized(parentPlot0); | ||||
} | ||||
void PythonQtShell_QCPLegend::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPLegend::selectEvent(event0, additive1, details2, selectionStateChanged3); | ||||
} | ||||
double PythonQtShell_QCPLegend::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectTest"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
double returnValue; | ||||
void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result); | ||||
} else { | ||||
returnValue = *((double*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPLegend::selectTest(pos0, onlySelectable1, details2); | ||||
} | ||||
QCPLegend* PythonQtWrapper_QCPLegend::new_QCPLegend() | ||||
{ | ||||
return new PythonQtShell_QCPLegend(); } | ||||
bool PythonQtWrapper_QCPLegend::addItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem* item) | ||||
{ | ||||
return ( theWrappedObject->addItem(item)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::applyDefaultAntialiasingHint(QCPLegend* theWrappedObject, QCPPainter* painter) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter)); | ||||
} | ||||
QPen PythonQtWrapper_QCPLegend::borderPen(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->borderPen()); | ||||
} | ||||
QBrush PythonQtWrapper_QCPLegend::brush(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->brush()); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::clearItems(QCPLegend* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->clearItems()); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::deselectEvent(QCPLegend* theWrappedObject, bool* selectionStateChanged) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::draw(QCPLegend* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_draw(painter)); | ||||
} | ||||
QFont PythonQtWrapper_QCPLegend::font(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->font()); | ||||
} | ||||
QPen PythonQtWrapper_QCPLegend::getBorderPen(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_getBorderPen()); | ||||
} | ||||
QBrush PythonQtWrapper_QCPLegend::getBrush(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_getBrush()); | ||||
} | ||||
bool PythonQtWrapper_QCPLegend::hasItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem* item) const | ||||
{ | ||||
return ( theWrappedObject->hasItem(item)); | ||||
} | ||||
QPen PythonQtWrapper_QCPLegend::iconBorderPen(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->iconBorderPen()); | ||||
} | ||||
QSize PythonQtWrapper_QCPLegend::iconSize(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->iconSize()); | ||||
} | ||||
int PythonQtWrapper_QCPLegend::iconTextPadding(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->iconTextPadding()); | ||||
} | ||||
QCPAbstractLegendItem* PythonQtWrapper_QCPLegend::item(QCPLegend* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->item(index)); | ||||
} | ||||
int PythonQtWrapper_QCPLegend::itemCount(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->itemCount()); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::parentPlotInitialized(QCPLegend* theWrappedObject, QCustomPlot* parentPlot) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_parentPlotInitialized(parentPlot)); | ||||
} | ||||
bool PythonQtWrapper_QCPLegend::removeItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem* item) | ||||
{ | ||||
return ( theWrappedObject->removeItem(item)); | ||||
} | ||||
bool PythonQtWrapper_QCPLegend::removeItem(QCPLegend* theWrappedObject, int index) | ||||
{ | ||||
return ( theWrappedObject->removeItem(index)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::selectEvent(QCPLegend* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged)); | ||||
} | ||||
double PythonQtWrapper_QCPLegend::selectTest(QCPLegend* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details)); | ||||
} | ||||
QPen PythonQtWrapper_QCPLegend::selectedBorderPen(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedBorderPen()); | ||||
} | ||||
QBrush PythonQtWrapper_QCPLegend::selectedBrush(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedBrush()); | ||||
} | ||||
QFont PythonQtWrapper_QCPLegend::selectedFont(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedFont()); | ||||
} | ||||
QPen PythonQtWrapper_QCPLegend::selectedIconBorderPen(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedIconBorderPen()); | ||||
} | ||||
QList<QCPAbstractLegendItem* > PythonQtWrapper_QCPLegend::selectedItems(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedItems()); | ||||
} | ||||
QColor PythonQtWrapper_QCPLegend::selectedTextColor(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedTextColor()); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setBorderPen(QCPLegend* theWrappedObject, const QPen& pen) | ||||
{ | ||||
( theWrappedObject->setBorderPen(pen)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setBrush(QCPLegend* theWrappedObject, const QBrush& brush) | ||||
{ | ||||
( theWrappedObject->setBrush(brush)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setFont(QCPLegend* theWrappedObject, const QFont& font) | ||||
{ | ||||
( theWrappedObject->setFont(font)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setIconBorderPen(QCPLegend* theWrappedObject, const QPen& pen) | ||||
{ | ||||
( theWrappedObject->setIconBorderPen(pen)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setIconSize(QCPLegend* theWrappedObject, const QSize& size) | ||||
{ | ||||
( theWrappedObject->setIconSize(size)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setIconSize(QCPLegend* theWrappedObject, int width, int height) | ||||
{ | ||||
( theWrappedObject->setIconSize(width, height)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setIconTextPadding(QCPLegend* theWrappedObject, int padding) | ||||
{ | ||||
( theWrappedObject->setIconTextPadding(padding)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setSelectedBorderPen(QCPLegend* theWrappedObject, const QPen& pen) | ||||
{ | ||||
( theWrappedObject->setSelectedBorderPen(pen)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setSelectedBrush(QCPLegend* theWrappedObject, const QBrush& brush) | ||||
{ | ||||
( theWrappedObject->setSelectedBrush(brush)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setSelectedFont(QCPLegend* theWrappedObject, const QFont& font) | ||||
{ | ||||
( theWrappedObject->setSelectedFont(font)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setSelectedIconBorderPen(QCPLegend* theWrappedObject, const QPen& pen) | ||||
{ | ||||
( theWrappedObject->setSelectedIconBorderPen(pen)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setSelectedTextColor(QCPLegend* theWrappedObject, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setSelectedTextColor(color)); | ||||
} | ||||
void PythonQtWrapper_QCPLegend::setTextColor(QCPLegend* theWrappedObject, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setTextColor(color)); | ||||
} | ||||
QColor PythonQtWrapper_QCPLegend::textColor(QCPLegend* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textColor()); | ||||
} | ||||
PythonQtShell_QCPPainter::~PythonQtShell_QCPPainter() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QCPPainter* PythonQtWrapper_QCPPainter::new_QCPPainter() | ||||
{ | ||||
return new PythonQtShell_QCPPainter(); } | ||||
QCPPainter* PythonQtWrapper_QCPPainter::new_QCPPainter(QPaintDevice* device) | ||||
{ | ||||
return new PythonQtShell_QCPPainter(device); } | ||||
bool PythonQtWrapper_QCPPainter::antialiasing(QCPPainter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->antialiasing()); | ||||
} | ||||
bool PythonQtWrapper_QCPPainter::begin(QCPPainter* theWrappedObject, QPaintDevice* device) | ||||
{ | ||||
return ( theWrappedObject->begin(device)); | ||||
} | ||||
void PythonQtWrapper_QCPPainter::drawLine(QCPPainter* theWrappedObject, const QLineF& line) | ||||
{ | ||||
( theWrappedObject->drawLine(line)); | ||||
} | ||||
void PythonQtWrapper_QCPPainter::drawLine(QCPPainter* theWrappedObject, const QPointF& p1, const QPointF& p2) | ||||
{ | ||||
( theWrappedObject->drawLine(p1, p2)); | ||||
} | ||||
void PythonQtWrapper_QCPPainter::makeNonCosmetic(QCPPainter* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->makeNonCosmetic()); | ||||
} | ||||
void PythonQtWrapper_QCPPainter::restore(QCPPainter* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->restore()); | ||||
} | ||||
void PythonQtWrapper_QCPPainter::save(QCPPainter* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->save()); | ||||
} | ||||
void PythonQtWrapper_QCPPainter::setAntialiasing(QCPPainter* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setAntialiasing(enabled)); | ||||
} | ||||
void PythonQtWrapper_QCPPainter::setPen(QCPPainter* theWrappedObject, Qt::PenStyle penStyle) | ||||
{ | ||||
( theWrappedObject->setPen(penStyle)); | ||||
} | ||||
void PythonQtWrapper_QCPPainter::setPen(QCPPainter* theWrappedObject, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setPen(color)); | ||||
} | ||||
void PythonQtWrapper_QCPPainter::setPen(QCPPainter* theWrappedObject, const QPen& pen) | ||||
{ | ||||
( theWrappedObject->setPen(pen)); | ||||
} | ||||
PythonQtShell_QCPPlotTitle::~PythonQtShell_QCPPlotTitle() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::applyDefaultAntialiasingHint(QCPPainter* painter0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::applyDefaultAntialiasingHint(painter0); | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::childEvent(arg__1); | ||||
} | ||||
QRect PythonQtShell_QCPPlotTitle::clipRect() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("clipRect"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QRect"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QRect 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("clipRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPPlotTitle::clipRect(); | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::deselectEvent(bool* selectionStateChanged0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("deselectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&selectionStateChanged0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::deselectEvent(selectionStateChanged0); | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::draw(painter0); | ||||
} | ||||
QList<QCPLayoutElement* > PythonQtShell_QCPPlotTitle::elements(bool recursive0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("elements"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QList<QCPLayoutElement* > returnValue; | ||||
void* args[2] = {NULL, (void*)&recursive0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QList<QCPLayoutElement* >*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPPlotTitle::elements(recursive0); | ||||
} | ||||
bool PythonQtShell_QCPPlotTitle::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPPlotTitle::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QCPPlotTitle::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPPlotTitle::eventFilter(arg__1, arg__2); | ||||
} | ||||
QSize PythonQtShell_QCPPlotTitle::maximumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("maximumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("maximumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPPlotTitle::maximumSizeHint(); | ||||
} | ||||
QSize PythonQtShell_QCPPlotTitle::minimumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("minimumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("minimumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPPlotTitle::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::mouseDoubleClickEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseDoubleClickEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::mouseDoubleClickEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::mouseMoveEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseMoveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::mouseMoveEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::mousePressEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mousePressEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::mousePressEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::mouseReleaseEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseReleaseEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::mouseReleaseEvent(event0); | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::parentPlotInitialized(QCustomPlot* parentPlot0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("parentPlotInitialized"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCustomPlot*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&parentPlot0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::parentPlotInitialized(parentPlot0); | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::selectEvent(QMouseEvent* event0, bool additive1, const QVariant& details2, bool* selectionStateChanged3) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::selectEvent(event0, additive1, details2, selectionStateChanged3); | ||||
} | ||||
double PythonQtShell_QCPPlotTitle::selectTest(const QPointF& pos0, bool onlySelectable1, QVariant* details2) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("selectTest"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
double returnValue; | ||||
void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result); | ||||
} else { | ||||
returnValue = *((double*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCPPlotTitle::selectTest(pos0, onlySelectable1, details2); | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCPPlotTitle::wheelEvent(QWheelEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("wheelEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCPPlotTitle::wheelEvent(event0); | ||||
} | ||||
QCPPlotTitle* PythonQtWrapper_QCPPlotTitle::new_QCPPlotTitle(QCustomPlot* parentPlot) | ||||
{ | ||||
return new PythonQtShell_QCPPlotTitle(parentPlot); } | ||||
QCPPlotTitle* PythonQtWrapper_QCPPlotTitle::new_QCPPlotTitle(QCustomPlot* parentPlot, const QString& text) | ||||
{ | ||||
return new PythonQtShell_QCPPlotTitle(parentPlot, text); } | ||||
void PythonQtWrapper_QCPPlotTitle::applyDefaultAntialiasingHint(QCPPlotTitle* theWrappedObject, QCPPainter* painter) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter)); | ||||
} | ||||
void PythonQtWrapper_QCPPlotTitle::deselectEvent(QCPPlotTitle* theWrappedObject, bool* selectionStateChanged) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged)); | ||||
} | ||||
void PythonQtWrapper_QCPPlotTitle::draw(QCPPlotTitle* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_draw(painter)); | ||||
} | ||||
QFont PythonQtWrapper_QCPPlotTitle::font(QCPPlotTitle* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->font()); | ||||
} | ||||
QFont PythonQtWrapper_QCPPlotTitle::mainFont(QCPPlotTitle* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_mainFont()); | ||||
} | ||||
QColor PythonQtWrapper_QCPPlotTitle::mainTextColor(QCPPlotTitle* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_mainTextColor()); | ||||
} | ||||
QSize PythonQtWrapper_QCPPlotTitle::maximumSizeHint(QCPPlotTitle* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_maximumSizeHint()); | ||||
} | ||||
QSize PythonQtWrapper_QCPPlotTitle::minimumSizeHint(QCPPlotTitle* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_minimumSizeHint()); | ||||
} | ||||
void PythonQtWrapper_QCPPlotTitle::selectEvent(QCPPlotTitle* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged)); | ||||
} | ||||
double PythonQtWrapper_QCPPlotTitle::selectTest(QCPPlotTitle* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details)); | ||||
} | ||||
bool PythonQtWrapper_QCPPlotTitle::selectable(QCPPlotTitle* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectable()); | ||||
} | ||||
bool PythonQtWrapper_QCPPlotTitle::selected(QCPPlotTitle* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selected()); | ||||
} | ||||
QFont PythonQtWrapper_QCPPlotTitle::selectedFont(QCPPlotTitle* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedFont()); | ||||
} | ||||
QColor PythonQtWrapper_QCPPlotTitle::selectedTextColor(QCPPlotTitle* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedTextColor()); | ||||
} | ||||
void PythonQtWrapper_QCPPlotTitle::setFont(QCPPlotTitle* theWrappedObject, const QFont& font) | ||||
{ | ||||
( theWrappedObject->setFont(font)); | ||||
} | ||||
void PythonQtWrapper_QCPPlotTitle::setSelectable(QCPPlotTitle* theWrappedObject, bool selectable) | ||||
{ | ||||
( theWrappedObject->setSelectable(selectable)); | ||||
} | ||||
void PythonQtWrapper_QCPPlotTitle::setSelected(QCPPlotTitle* theWrappedObject, bool selected) | ||||
{ | ||||
( theWrappedObject->setSelected(selected)); | ||||
} | ||||
void PythonQtWrapper_QCPPlotTitle::setSelectedFont(QCPPlotTitle* theWrappedObject, const QFont& font) | ||||
{ | ||||
( theWrappedObject->setSelectedFont(font)); | ||||
} | ||||
void PythonQtWrapper_QCPPlotTitle::setSelectedTextColor(QCPPlotTitle* theWrappedObject, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setSelectedTextColor(color)); | ||||
} | ||||
void PythonQtWrapper_QCPPlotTitle::setText(QCPPlotTitle* theWrappedObject, const QString& text) | ||||
{ | ||||
( theWrappedObject->setText(text)); | ||||
} | ||||
void PythonQtWrapper_QCPPlotTitle::setTextColor(QCPPlotTitle* theWrappedObject, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setTextColor(color)); | ||||
} | ||||
QString PythonQtWrapper_QCPPlotTitle::text(QCPPlotTitle* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->text()); | ||||
} | ||||
QColor PythonQtWrapper_QCPPlotTitle::textColor(QCPPlotTitle* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textColor()); | ||||
} | ||||
PythonQtShell_QCustomPlot::~PythonQtShell_QCustomPlot() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QCustomPlot::actionEvent(QActionEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("actionEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::axisRemoved(QCPAxis* axis0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("axisRemoved"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPAxis*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&axis0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::axisRemoved(axis0); | ||||
} | ||||
void PythonQtShell_QCustomPlot::changeEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("changeEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::closeEvent(QCloseEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("closeEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::contextMenuEvent(QContextMenuEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("contextMenuEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QCustomPlot::devType() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("devType"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::devType(); | ||||
} | ||||
void PythonQtShell_QCustomPlot::dragEnterEvent(QDragEnterEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("dragEnterEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::dragLeaveEvent(QDragLeaveEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("dragLeaveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::dragMoveEvent(QDragMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("dragMoveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::draw(QCPPainter* painter0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("draw"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::draw(painter0); | ||||
} | ||||
void PythonQtShell_QCustomPlot::dropEvent(QDropEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("dropEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::enterEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("enterEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QCustomPlot::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QCustomPlot::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QCustomPlot::focusInEvent(QFocusEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("focusInEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QCustomPlot::focusNextPrevChild(bool next0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("focusNextPrevChild"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"bool" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&next0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::focusNextPrevChild(next0); | ||||
} | ||||
void PythonQtShell_QCustomPlot::focusOutEvent(QFocusEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("focusOutEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::focusOutEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QCustomPlot::hasHeightForWidth() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("hasHeightForWidth"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::hasHeightForWidth(); | ||||
} | ||||
int PythonQtShell_QCustomPlot::heightForWidth(int arg__1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("heightForWidth"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::hideEvent(QHideEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("hideEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::initPainter(QPainter* painter0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("initPainter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::initPainter(painter0); | ||||
} | ||||
void PythonQtShell_QCustomPlot::inputMethodEvent(QInputMethodEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("inputMethodEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QCustomPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("inputMethodQuery"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::keyPressEvent(QKeyEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("keyPressEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::keyReleaseEvent(QKeyEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("keyReleaseEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::leaveEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("leaveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::leaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::legendRemoved(QCPLegend* legend0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("legendRemoved"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QCPLegend*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&legend0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::legendRemoved(legend0); | ||||
} | ||||
int PythonQtShell_QCustomPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("metric"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::metric(arg__1); | ||||
} | ||||
QSize PythonQtShell_QCustomPlot::minimumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("minimumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("minimumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QCustomPlot::mouseDoubleClickEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseDoubleClickEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::mouseDoubleClickEvent(event0); | ||||
} | ||||
void PythonQtShell_QCustomPlot::mouseMoveEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseMoveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::mouseMoveEvent(event0); | ||||
} | ||||
void PythonQtShell_QCustomPlot::mousePressEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mousePressEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::mousePressEvent(event0); | ||||
} | ||||
void PythonQtShell_QCustomPlot::mouseReleaseEvent(QMouseEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseReleaseEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::mouseReleaseEvent(event0); | ||||
} | ||||
void PythonQtShell_QCustomPlot::moveEvent(QMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("moveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::moveEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QCustomPlot::nativeEvent(const QByteArray& eventType0, void* message1, long* result2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("nativeEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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*)&eventType0, (void*)&message1, (void*)&result2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::nativeEvent(eventType0, message1, result2); | ||||
} | ||||
QPaintEngine* PythonQtShell_QCustomPlot::paintEngine() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("paintEngine"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::paintEngine(); | ||||
} | ||||
void PythonQtShell_QCustomPlot::paintEvent(QPaintEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("paintEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QPaintEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::paintEvent(event0); | ||||
} | ||||
QPaintDevice* PythonQtShell_QCustomPlot::redirected(QPoint* offset0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("redirected"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPaintDevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&offset0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::redirected(offset0); | ||||
} | ||||
void PythonQtShell_QCustomPlot::resizeEvent(QResizeEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("resizeEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QResizeEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::resizeEvent(event0); | ||||
} | ||||
QPainter* PythonQtShell_QCustomPlot::sharedPainter() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("sharedPainter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::sharedPainter(); | ||||
} | ||||
void PythonQtShell_QCustomPlot::showEvent(QShowEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("showEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::showEvent(arg__1); | ||||
} | ||||
QSize PythonQtShell_QCustomPlot::sizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("sizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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("sizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QCustomPlot::sizeHint(); | ||||
} | ||||
void PythonQtShell_QCustomPlot::tabletEvent(QTabletEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("tabletEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QCustomPlot::wheelEvent(QWheelEvent* event0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("wheelEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QCustomPlot::wheelEvent(event0); | ||||
} | ||||
QCustomPlot* PythonQtWrapper_QCustomPlot::new_QCustomPlot(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QCustomPlot(parent); } | ||||
QCPGraph* PythonQtWrapper_QCustomPlot::addGraph(QCustomPlot* theWrappedObject, QCPAxis* keyAxis, QCPAxis* valueAxis) | ||||
{ | ||||
return ( theWrappedObject->addGraph(keyAxis, valueAxis)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::addItem(QCustomPlot* theWrappedObject, QCPAbstractItem* item) | ||||
{ | ||||
return ( theWrappedObject->addItem(item)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::autoAddPlottableToLegend(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoAddPlottableToLegend()); | ||||
} | ||||
QCPAxisRect* PythonQtWrapper_QCustomPlot::axisRect(QCustomPlot* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->axisRect(index)); | ||||
} | ||||
int PythonQtWrapper_QCustomPlot::axisRectCount(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->axisRectCount()); | ||||
} | ||||
QList<QCPAxisRect* > PythonQtWrapper_QCustomPlot::axisRects(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->axisRects()); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::axisRemoved(QCustomPlot* theWrappedObject, QCPAxis* axis) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_axisRemoved(axis)); | ||||
} | ||||
QPixmap PythonQtWrapper_QCustomPlot::background(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->background()); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::backgroundScaled(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->backgroundScaled()); | ||||
} | ||||
Qt::AspectRatioMode PythonQtWrapper_QCustomPlot::backgroundScaledMode(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->backgroundScaledMode()); | ||||
} | ||||
int PythonQtWrapper_QCustomPlot::clearGraphs(QCustomPlot* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->clearGraphs()); | ||||
} | ||||
int PythonQtWrapper_QCustomPlot::clearItems(QCustomPlot* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->clearItems()); | ||||
} | ||||
int PythonQtWrapper_QCustomPlot::clearPlottables(QCustomPlot* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->clearPlottables()); | ||||
} | ||||
QCPLayer* PythonQtWrapper_QCustomPlot::currentLayer(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentLayer()); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::deselectAll(QCustomPlot* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->deselectAll()); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::draw(QCustomPlot* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_draw(painter)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::drawBackground(QCustomPlot* theWrappedObject, QCPPainter* painter) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_drawBackground(painter)); | ||||
} | ||||
QCPGraph* PythonQtWrapper_QCustomPlot::graph(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->graph()); | ||||
} | ||||
QCPGraph* PythonQtWrapper_QCustomPlot::graph(QCustomPlot* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->graph(index)); | ||||
} | ||||
int PythonQtWrapper_QCustomPlot::graphCount(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->graphCount()); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::hasItem(QCustomPlot* theWrappedObject, QCPAbstractItem* item) const | ||||
{ | ||||
return ( theWrappedObject->hasItem(item)); | ||||
} | ||||
QCPAbstractItem* PythonQtWrapper_QCustomPlot::item(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->item()); | ||||
} | ||||
QCPAbstractItem* PythonQtWrapper_QCustomPlot::item(QCustomPlot* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->item(index)); | ||||
} | ||||
QCPAbstractItem* PythonQtWrapper_QCustomPlot::itemAt(QCustomPlot* theWrappedObject, const QPointF& pos, bool onlySelectable) const | ||||
{ | ||||
return ( theWrappedObject->itemAt(pos, onlySelectable)); | ||||
} | ||||
int PythonQtWrapper_QCustomPlot::itemCount(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->itemCount()); | ||||
} | ||||
QCPLayer* PythonQtWrapper_QCustomPlot::layer(QCustomPlot* theWrappedObject, const QString& name) const | ||||
{ | ||||
return ( theWrappedObject->layer(name)); | ||||
} | ||||
QCPLayer* PythonQtWrapper_QCustomPlot::layer(QCustomPlot* theWrappedObject, int index) const | ||||
{ | ||||
return ( theWrappedObject->layer(index)); | ||||
} | ||||
int PythonQtWrapper_QCustomPlot::layerCount(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->layerCount()); | ||||
} | ||||
QCPLayerable* PythonQtWrapper_QCustomPlot::layerableAt(QCustomPlot* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* selectionDetails) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_layerableAt(pos, onlySelectable, selectionDetails)); | ||||
} | ||||
QCPLayoutElement* PythonQtWrapper_QCustomPlot::layoutElementAt(QCustomPlot* theWrappedObject, const QPointF& pos) const | ||||
{ | ||||
return ( theWrappedObject->layoutElementAt(pos)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::legendRemoved(QCustomPlot* theWrappedObject, QCPLegend* legend) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_legendRemoved(legend)); | ||||
} | ||||
QSize PythonQtWrapper_QCustomPlot::minimumSizeHint(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_minimumSizeHint()); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::mouseDoubleClickEvent(QCustomPlot* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_mouseDoubleClickEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::mouseMoveEvent(QCustomPlot* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_mouseMoveEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::mousePressEvent(QCustomPlot* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_mousePressEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::mouseReleaseEvent(QCustomPlot* theWrappedObject, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_mouseReleaseEvent(event)); | ||||
} | ||||
Qt::KeyboardModifier PythonQtWrapper_QCustomPlot::multiSelectModifier(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->multiSelectModifier()); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::noAntialiasingOnDrag(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->noAntialiasingOnDrag()); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::paintEvent(QCustomPlot* theWrappedObject, QPaintEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_paintEvent(event)); | ||||
} | ||||
int PythonQtWrapper_QCustomPlot::plottableCount(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->plottableCount()); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::removeGraph(QCustomPlot* theWrappedObject, QCPGraph* graph) | ||||
{ | ||||
return ( theWrappedObject->removeGraph(graph)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::removeGraph(QCustomPlot* theWrappedObject, int index) | ||||
{ | ||||
return ( theWrappedObject->removeGraph(index)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::removeItem(QCustomPlot* theWrappedObject, QCPAbstractItem* item) | ||||
{ | ||||
return ( theWrappedObject->removeItem(item)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::removeItem(QCustomPlot* theWrappedObject, int index) | ||||
{ | ||||
return ( theWrappedObject->removeItem(index)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::removeLayer(QCustomPlot* theWrappedObject, QCPLayer* layer) | ||||
{ | ||||
return ( theWrappedObject->removeLayer(layer)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::removePlottable(QCustomPlot* theWrappedObject, int index) | ||||
{ | ||||
return ( theWrappedObject->removePlottable(index)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::rescaleAxes(QCustomPlot* theWrappedObject, bool onlyVisiblePlottables) | ||||
{ | ||||
( theWrappedObject->rescaleAxes(onlyVisiblePlottables)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::resizeEvent(QCustomPlot* theWrappedObject, QResizeEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_resizeEvent(event)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::saveBmp(QCustomPlot* theWrappedObject, const QString& fileName, int width, int height, double scale) | ||||
{ | ||||
return ( theWrappedObject->saveBmp(fileName, width, height, scale)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::saveJpg(QCustomPlot* theWrappedObject, const QString& fileName, int width, int height, double scale, int quality) | ||||
{ | ||||
return ( theWrappedObject->saveJpg(fileName, width, height, scale, quality)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::savePdf(QCustomPlot* theWrappedObject, const QString& fileName, bool noCosmeticPen, int width, int height, const QString& pdfCreator, const QString& pdfTitle) | ||||
{ | ||||
return ( theWrappedObject->savePdf(fileName, noCosmeticPen, width, height, pdfCreator, pdfTitle)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::savePng(QCustomPlot* theWrappedObject, const QString& fileName, int width, int height, double scale, int quality) | ||||
{ | ||||
return ( theWrappedObject->savePng(fileName, width, height, scale, quality)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::saveRastered(QCustomPlot* theWrappedObject, const QString& fileName, int width, int height, double scale, const char* format, int quality) | ||||
{ | ||||
return ( theWrappedObject->saveRastered(fileName, width, height, scale, format, quality)); | ||||
} | ||||
QList<QCPAxis* > PythonQtWrapper_QCustomPlot::selectedAxes(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedAxes()); | ||||
} | ||||
QList<QCPGraph* > PythonQtWrapper_QCustomPlot::selectedGraphs(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedGraphs()); | ||||
} | ||||
QList<QCPAbstractItem* > PythonQtWrapper_QCustomPlot::selectedItems(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedItems()); | ||||
} | ||||
QList<QCPLegend* > PythonQtWrapper_QCustomPlot::selectedLegends(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedLegends()); | ||||
} | ||||
int PythonQtWrapper_QCustomPlot::selectionTolerance(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectionTolerance()); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::setAutoAddPlottableToLegend(QCustomPlot* theWrappedObject, bool on) | ||||
{ | ||||
( theWrappedObject->setAutoAddPlottableToLegend(on)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::setBackground(QCustomPlot* theWrappedObject, const QBrush& brush) | ||||
{ | ||||
( theWrappedObject->setBackground(brush)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::setBackground(QCustomPlot* theWrappedObject, const QPixmap& pm) | ||||
{ | ||||
( theWrappedObject->setBackground(pm)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::setBackground(QCustomPlot* theWrappedObject, const QPixmap& pm, bool scaled, Qt::AspectRatioMode mode) | ||||
{ | ||||
( theWrappedObject->setBackground(pm, scaled, mode)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::setBackgroundScaled(QCustomPlot* theWrappedObject, bool scaled) | ||||
{ | ||||
( theWrappedObject->setBackgroundScaled(scaled)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::setBackgroundScaledMode(QCustomPlot* theWrappedObject, Qt::AspectRatioMode mode) | ||||
{ | ||||
( theWrappedObject->setBackgroundScaledMode(mode)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::setCurrentLayer(QCustomPlot* theWrappedObject, QCPLayer* layer) | ||||
{ | ||||
return ( theWrappedObject->setCurrentLayer(layer)); | ||||
} | ||||
bool PythonQtWrapper_QCustomPlot::setCurrentLayer(QCustomPlot* theWrappedObject, const QString& name) | ||||
{ | ||||
return ( theWrappedObject->setCurrentLayer(name)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::setMultiSelectModifier(QCustomPlot* theWrappedObject, Qt::KeyboardModifier modifier) | ||||
{ | ||||
( theWrappedObject->setMultiSelectModifier(modifier)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::setNoAntialiasingOnDrag(QCustomPlot* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setNoAntialiasingOnDrag(enabled)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::setSelectionTolerance(QCustomPlot* theWrappedObject, int pixels) | ||||
{ | ||||
( theWrappedObject->setSelectionTolerance(pixels)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::setViewport(QCustomPlot* theWrappedObject, const QRect& rect) | ||||
{ | ||||
( theWrappedObject->setViewport(rect)); | ||||
} | ||||
QSize PythonQtWrapper_QCustomPlot::sizeHint(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_sizeHint()); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::toPainter(QCustomPlot* theWrappedObject, QCPPainter* painter, int width, int height) | ||||
{ | ||||
( theWrappedObject->toPainter(painter, width, height)); | ||||
} | ||||
QPixmap PythonQtWrapper_QCustomPlot::toPixmap(QCustomPlot* theWrappedObject, int width, int height, double scale) | ||||
{ | ||||
return ( theWrappedObject->toPixmap(width, height, scale)); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::updateLayerIndices(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_updateLayerIndices()); | ||||
} | ||||
QRect PythonQtWrapper_QCustomPlot::viewport(QCustomPlot* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->viewport()); | ||||
} | ||||
void PythonQtWrapper_QCustomPlot::wheelEvent(QCustomPlot* theWrappedObject, QWheelEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_wheelEvent(event)); | ||||
} | ||||
PythonQtShell_QLopData::~PythonQtShell_QLopData() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QLopData::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QLopData::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLopData::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QLopData::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QLopData::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QLopData::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QLopData::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QLopData::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QLopData::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QLopData::timerEvent(arg__1); | ||||
} | ||||
QLopData* PythonQtWrapper_QLopData::new_QLopData(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QLopData(parent); } | ||||
QLopDataList* PythonQtWrapper_QLopDataList::new_QLopDataList() | ||||
{ | ||||
return new QLopDataList(); } | ||||
QLopDataList* PythonQtWrapper_QLopDataList::new_QLopDataList(const QList<QLopData* >& l) | ||||
{ | ||||
return new QLopDataList(l); } | ||||
void PythonQtWrapper_QLopDataList::append(QLopDataList* theWrappedObject, QLopData* t) | ||||
{ | ||||
( theWrappedObject->append(t)); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::append(QLopDataList* theWrappedObject, const QList<QLopData* >& t) | ||||
{ | ||||
( theWrappedObject->append(t)); | ||||
} | ||||
QLopData* PythonQtWrapper_QLopDataList::at(QLopDataList* theWrappedObject, int i) const | ||||
{ | ||||
return ( theWrappedObject->at(i)); | ||||
} | ||||
QLopData* PythonQtWrapper_QLopDataList::back(QLopDataList* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->back()); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::clear(QLopDataList* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->clear()); | ||||
} | ||||
bool PythonQtWrapper_QLopDataList::contains(QLopDataList* theWrappedObject, QLopData* t) const | ||||
{ | ||||
return ( theWrappedObject->contains(t)); | ||||
} | ||||
int PythonQtWrapper_QLopDataList::count(QLopDataList* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->count()); | ||||
} | ||||
int PythonQtWrapper_QLopDataList::count(QLopDataList* theWrappedObject, QLopData* t) const | ||||
{ | ||||
return ( theWrappedObject->count(t)); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::detachShared(QLopDataList* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->detachShared()); | ||||
} | ||||
bool PythonQtWrapper_QLopDataList::empty(QLopDataList* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->empty()); | ||||
} | ||||
bool PythonQtWrapper_QLopDataList::endsWith(QLopDataList* theWrappedObject, QLopData* t) const | ||||
{ | ||||
return ( theWrappedObject->endsWith(t)); | ||||
} | ||||
QLopData* PythonQtWrapper_QLopDataList::first(QLopDataList* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->first()); | ||||
} | ||||
QList<QLopData* > PythonQtWrapper_QLopDataList::static_QLopDataList_fromVector(const QVector<QLopData* >& vector) | ||||
{ | ||||
return (QLopDataList::fromVector(vector)); | ||||
} | ||||
QLopData* PythonQtWrapper_QLopDataList::front(QLopDataList* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->front()); | ||||
} | ||||
int PythonQtWrapper_QLopDataList::indexOf(QLopDataList* theWrappedObject, QLopData* t, int from) const | ||||
{ | ||||
return ( theWrappedObject->indexOf(t, from)); | ||||
} | ||||
bool PythonQtWrapper_QLopDataList::isEmpty(QLopDataList* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isEmpty()); | ||||
} | ||||
bool PythonQtWrapper_QLopDataList::isSharedWith(QLopDataList* theWrappedObject, const QList<QLopData* >& other) const | ||||
{ | ||||
return ( theWrappedObject->isSharedWith(other)); | ||||
} | ||||
QLopData* PythonQtWrapper_QLopDataList::last(QLopDataList* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->last()); | ||||
} | ||||
int PythonQtWrapper_QLopDataList::lastIndexOf(QLopDataList* theWrappedObject, QLopData* t, int from) const | ||||
{ | ||||
return ( theWrappedObject->lastIndexOf(t, from)); | ||||
} | ||||
int PythonQtWrapper_QLopDataList::length(QLopDataList* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->length()); | ||||
} | ||||
QList<QLopData* > PythonQtWrapper_QLopDataList::mid(QLopDataList* theWrappedObject, int pos, int length) const | ||||
{ | ||||
return ( theWrappedObject->mid(pos, length)); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::move(QLopDataList* theWrappedObject, int from, int to) | ||||
{ | ||||
( theWrappedObject->move(from, to)); | ||||
} | ||||
bool PythonQtWrapper_QLopDataList::__ne__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) const | ||||
{ | ||||
return ( (*theWrappedObject)!= l); | ||||
} | ||||
QList<QLopData* > PythonQtWrapper_QLopDataList::__add__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) const | ||||
{ | ||||
return ( (*theWrappedObject)+ l); | ||||
} | ||||
QList<QLopData* >* PythonQtWrapper_QLopDataList::__iadd__(QLopDataList* theWrappedObject, QLopData* t) | ||||
{ | ||||
return &( (*theWrappedObject)+= t); | ||||
} | ||||
QList<QLopData* >* PythonQtWrapper_QLopDataList::__iadd__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) | ||||
{ | ||||
return &( (*theWrappedObject)+= l); | ||||
} | ||||
QList<QLopData* >* PythonQtWrapper_QLopDataList::__lshift__(QLopDataList* theWrappedObject, QLopData* t) | ||||
{ | ||||
return &( (*theWrappedObject) <<t); | ||||
} | ||||
QList<QLopData* >* PythonQtWrapper_QLopDataList::__lshift__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) | ||||
{ | ||||
return &( (*theWrappedObject) <<l); | ||||
} | ||||
bool PythonQtWrapper_QLopDataList::__eq__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) const | ||||
{ | ||||
return ( (*theWrappedObject)== l); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::pop_back(QLopDataList* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->pop_back()); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::pop_front(QLopDataList* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->pop_front()); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::prepend(QLopDataList* theWrappedObject, QLopData* t) | ||||
{ | ||||
( theWrappedObject->prepend(t)); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::push_back(QLopDataList* theWrappedObject, QLopData* t) | ||||
{ | ||||
( theWrappedObject->push_back(t)); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::push_front(QLopDataList* theWrappedObject, QLopData* t) | ||||
{ | ||||
( theWrappedObject->push_front(t)); | ||||
} | ||||
int PythonQtWrapper_QLopDataList::removeAll(QLopDataList* theWrappedObject, QLopData* t) | ||||
{ | ||||
return ( theWrappedObject->removeAll(t)); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::removeAt(QLopDataList* theWrappedObject, int i) | ||||
{ | ||||
( theWrappedObject->removeAt(i)); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::removeFirst(QLopDataList* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->removeFirst()); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::removeLast(QLopDataList* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->removeLast()); | ||||
} | ||||
bool PythonQtWrapper_QLopDataList::removeOne(QLopDataList* theWrappedObject, QLopData* t) | ||||
{ | ||||
return ( theWrappedObject->removeOne(t)); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::replace(QLopDataList* theWrappedObject, int i, QLopData* t) | ||||
{ | ||||
( theWrappedObject->replace(i, t)); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::reserve(QLopDataList* theWrappedObject, int size) | ||||
{ | ||||
( theWrappedObject->reserve(size)); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::setSharable(QLopDataList* theWrappedObject, bool sharable) | ||||
{ | ||||
( theWrappedObject->setSharable(sharable)); | ||||
} | ||||
int PythonQtWrapper_QLopDataList::size(QLopDataList* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->size()); | ||||
} | ||||
bool PythonQtWrapper_QLopDataList::startsWith(QLopDataList* theWrappedObject, QLopData* t) const | ||||
{ | ||||
return ( theWrappedObject->startsWith(t)); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::swap(QLopDataList* theWrappedObject, QList<QLopData* >& other) | ||||
{ | ||||
( theWrappedObject->swap(other)); | ||||
} | ||||
void PythonQtWrapper_QLopDataList::swap(QLopDataList* theWrappedObject, int i, int j) | ||||
{ | ||||
( theWrappedObject->swap(i, j)); | ||||
} | ||||
QLopData* PythonQtWrapper_QLopDataList::takeAt(QLopDataList* theWrappedObject, int i) | ||||
{ | ||||
return ( theWrappedObject->takeAt(i)); | ||||
} | ||||
QLopData* PythonQtWrapper_QLopDataList::takeFirst(QLopDataList* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->takeFirst()); | ||||
} | ||||
QLopData* PythonQtWrapper_QLopDataList::takeLast(QLopDataList* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->takeLast()); | ||||
} | ||||
QVector<QLopData* > PythonQtWrapper_QLopDataList::toVector(QLopDataList* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toVector()); | ||||
} | ||||
QLopData* PythonQtWrapper_QLopDataList::value(QLopDataList* theWrappedObject, int i) const | ||||
{ | ||||
return ( theWrappedObject->value(i)); | ||||
} | ||||
QLopData* PythonQtWrapper_QLopDataList::value(QLopDataList* theWrappedObject, int i, QLopData* defaultValue) const | ||||
{ | ||||
return ( theWrappedObject->value(i, defaultValue)); | ||||
} | ||||
r5 | PythonQtShell_QLopService::~PythonQtShell_QLopService() { | |||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QLopService::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QLopService::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLopService::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QLopService::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QLopService::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QLopService::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QLopService::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return QLopService::eventFilter(arg__1, arg__2); | ||||
} | ||||
QDockWidget* PythonQtShell_QLopService::getGUI() | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("getGUI"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QDockWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QDockWidget* 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("getGUI", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QDockWidget**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return 0; | ||||
} | ||||
const QString& PythonQtShell_QLopService::serviceName() | ||||
{ | ||||
return QLopService::serviceName(); | ||||
} | ||||
void PythonQtShell_QLopService::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
QLopService::timerEvent(arg__1); | ||||
} | ||||
QLopService* PythonQtWrapper_QLopService::new_QLopService(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QLopService(parent); } | ||||
QDockWidget* PythonQtWrapper_QLopService::getGUI(QLopService* theWrappedObject) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QLopService*)theWrappedObject)->promoted_getGUI()); | ||||
} | ||||
const QString* PythonQtWrapper_QLopService::serviceName(QLopService* theWrappedObject) | ||||
{ | ||||
return &( ((PythonQtPublicPromoter_QLopService*)theWrappedObject)->promoted_serviceName()); | ||||
} | ||||
PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("actionEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("changeEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("childEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("closeEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("contextMenuEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("customEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_SocExplorerPlot::devType() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("devType"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::devType(); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("dragEnterEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("dragLeaveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("dragMoveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("dropEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("enterEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("event"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::event(arg__1); | ||||
} | ||||
bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("eventFilter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("focusInEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next0) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("focusNextPrevChild"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"bool" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&next0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::focusNextPrevChild(next0); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("focusOutEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::focusOutEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("hasHeightForWidth"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::hasHeightForWidth(); | ||||
} | ||||
int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("heightForWidth"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("hideEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("initPainter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"" , "QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::initPainter(painter0); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("inputMethodEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("inputMethodQuery"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("keyPressEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("keyReleaseEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("leaveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("metric"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::metric(arg__1); | ||||
} | ||||
QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("getMinimumSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseDoubleClickEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseMoveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mousePressEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("mouseReleaseEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("moveEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::moveEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType0, void* message1, long* result2) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("nativeEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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*)&eventType0, (void*)&message1, (void*)&result2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::nativeEvent(eventType0, message1, result2); | ||||
} | ||||
QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("paintEngine"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::paintEngine(); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("paintEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::paintEvent(arg__1); | ||||
} | ||||
QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset0) const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("redirected"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (obj) { | ||||
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPaintDevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&offset0}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::redirected(offset0); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("resizeEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::resizeEvent(arg__1); | ||||
} | ||||
QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("sharedPainter"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::sharedPainter(); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("showEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::showEvent(arg__1); | ||||
} | ||||
QSize PythonQtShell_SocExplorerPlot::sizeHint() const | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("getSizeHint"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
return SocExplorerPlot::sizeHint(); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("tabletEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("timerEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1) | ||||
{ | ||||
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) { | ||||
static PyObject* name = PyString_FromString("wheelEvent"); | ||||
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); | ||||
if (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; | ||||
} else { | ||||
PyErr_Clear(); | ||||
} | ||||
} | ||||
SocExplorerPlot::wheelEvent(arg__1); | ||||
} | ||||
SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_SocExplorerPlot(parent); } | ||||
int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->addGraph()); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y) | ||||
{ | ||||
( theWrappedObject->addGraphData(graphIndex, x, y)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y) | ||||
{ | ||||
( theWrappedObject->addGraphData(graphIndex, x, y)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::exportToPDF(SocExplorerPlot* theWrappedObject, const QString& fileName) | ||||
{ | ||||
( theWrappedObject->exportToPDF(fileName)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::exportToSVG(SocExplorerPlot* theWrappedObject, const QString& fileName) | ||||
{ | ||||
( theWrappedObject->exportToSVG(fileName)); | ||||
} | ||||
QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex) | ||||
{ | ||||
return ( theWrappedObject->getGraphPen(graphIndex)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::removeAllGraphs(SocExplorerPlot* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->removeAllGraphs()); | ||||
} | ||||
bool PythonQtWrapper_SocExplorerPlot::removeGraph(SocExplorerPlot* theWrappedObject, int graphIndex) | ||||
{ | ||||
return ( theWrappedObject->removeGraph(graphIndex)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::replot(SocExplorerPlot* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->replot()); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->rescaleAxis()); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable) | ||||
{ | ||||
( theWrappedObject->setAdaptativeSampling(graphIndex, enable)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y) | ||||
{ | ||||
( theWrappedObject->setGraphData(graphIndex, x, y)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle) | ||||
{ | ||||
( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name) | ||||
{ | ||||
( theWrappedObject->setGraphName(graphIndex, name)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen) | ||||
{ | ||||
( theWrappedObject->setGraphPen(graphIndex, pen)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle) | ||||
{ | ||||
( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font) | ||||
{ | ||||
( theWrappedObject->setLegendFont(font)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font) | ||||
{ | ||||
( theWrappedObject->setLegendSelectedFont(font)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title) | ||||
{ | ||||
( theWrappedObject->setTitle(title)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setUseFastVector(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable) | ||||
{ | ||||
( theWrappedObject->setUseFastVector(graphIndex, enable)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setXaxisDateTimeFormat(SocExplorerPlot* theWrappedObject, const QString& format) | ||||
{ | ||||
( theWrappedObject->setXaxisDateTimeFormat(format)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label) | ||||
{ | ||||
( theWrappedObject->setXaxisLabel(label)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper) | ||||
{ | ||||
( theWrappedObject->setXaxisRange(lower, upper)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label) | ||||
{ | ||||
( theWrappedObject->setYaxisLabel(label)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper) | ||||
{ | ||||
( theWrappedObject->setYaxisRange(lower, upper)); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->show()); | ||||
} | ||||
void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1)); | ||||
} | ||||