diff --git a/QLop.pro b/QLop.pro --- a/QLop.pro +++ b/QLop.pro @@ -50,7 +50,9 @@ SOURCES += src/main.cpp\ src/Core/qlopdata.cpp \ src/Core/Widgets/PyWdgt/pythonconsole.cpp \ src/Core/Widgets/PyWdgt/pythonqtscriptingconsoledandd.cpp \ - src/QCustomPlot/qcpdocumentobject.cpp + src/QCustomPlot/qcpdocumentobject.cpp \ + src/Core/Widgets/filebrowser.cpp \ + src/Core/Widgets/filesystemmodel.cpp HEADERS += src/mainwindow.h \ src/SocExplorerPlot.h \ @@ -77,7 +79,9 @@ HEADERS += src/mainwindow.h \ src/Core/Widgets/PyWdgt/pythonqtscriptingconsoledandd.h \ src/Core/qlop.h \ src/Core/pyqlop.h \ - src/QCustomPlot/qcpdocumentobject.h + src/QCustomPlot/qcpdocumentobject.h \ + src/Core/Widgets/filebrowser.h \ + src/Core/Widgets/filesystemmodel.h FORMS += src/mainwindow.ui \ src/folderview.ui \ @@ -85,7 +89,8 @@ FORMS += src/mainwindow.ui \ src/Core/Widgets/downloadhistoryelement.ui \ src/Cassini/cassinidatadownloader.ui \ src/Cassini/cassiniindexfileviewer.ui \ - src/Cassini/cassinitoolsgui.ui + src/Cassini/cassinitoolsgui.ui \ + src/Core/Widgets/filebrowser.ui RESOURCES += \ resources/qlop.qrc diff --git a/resources/Credits.txt b/resources/Credits.txt new file mode 100644 --- /dev/null +++ b/resources/Credits.txt @@ -0,0 +1,2 @@ +ListView Icon : Quan Do @ https://thenounproject.com +TreeView Icon : Anisha Varghese @ https://thenounproject.com diff --git a/resources/Gnome-go-up.svg b/resources/Gnome-go-up.svg new file mode 100644 --- /dev/null +++ b/resources/Gnome-go-up.svg @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + + + + + image/svg+xml + + Go up + August 2006 + + + Andreas Nilsson + + + + + Jakub Steiner + + + http://www.gnome.org + + + up + arrow + go + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/resources/ListView.svg b/resources/ListView.svg new file mode 100644 --- /dev/null +++ b/resources/ListView.svg @@ -0,0 +1,54 @@ + + + + + http://thenounproject.com + The Noun ProjectIcon Template + Reminders + + + + + + + + + + + + + StrokesTry to keep strokes at 4pxMinimum stroke weight is 2pxFor thicker strokes use even numbers: 6px, 8px etc.Remember to expand strokes before saving as an SVG + + SizeCannot be wider or taller than 100px (artboard size)Scale your icon to fill as much of the artboard as possible + + UngroupIf your design has more than one shape, make sure to ungroup + + Save asSave as .SVG and make sure “Use Artboards” is checked + 100px + .SVG + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/TreeView.svg b/resources/TreeView.svg new file mode 100644 --- /dev/null +++ b/resources/TreeView.svg @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/resources/qlop.qrc b/resources/qlop.qrc --- a/resources/qlop.qrc +++ b/resources/qlop.qrc @@ -2,5 +2,8 @@ Gnome-view-refresh.svg Gnome-list-add.svg + ListView.svg + TreeView.svg + Gnome-go-up.svg diff --git a/src/Cassini/cassinitools.cpp b/src/Cassini/cassinitools.cpp --- a/src/Cassini/cassinitools.cpp +++ b/src/Cassini/cassinitools.cpp @@ -1,12 +1,13 @@ #include "cassinitools.h" #include #include +#include CassiniTools* CassiniTools::_self=NULL; QDockWidget* CassiniTools::m_gui=NULL; CassiniToolsGUI* CassiniTools::m_CassiniToolsGUI=NULL; CassiniDataFile* CassiniTools::m_dataFile=NULL; - +int CassiniTools::m_defaultPlot=-1; Qt::GlobalColor QLopColours[]= {Qt::black, Qt::red, @@ -44,6 +45,22 @@ CassiniTools::~CassiniTools() delete m_gui; } +void CassiniTools::makePlot() +{ + m_defaultPlot = QLopPlots::addPlot(); + SocExplorerPlot* plot=QLopPlots::getPlot(m_defaultPlot); + if(plot) + { + plot->setTitle(_self->m_serviceName + " plot"); + plot->setXaxisTickLabelType(QCPAxis::ltDateTime); + plot->setXaxisDateTimeFormat("hh:mm:ss.zzz"); + plot->setContextMenuPolicy(Qt::ActionsContextMenu); + QAction* action=new QAction("export view",_self); + plot->addAction(action); + QObject::connect(action,SIGNAL(triggered()),_self,SLOT(export_view())); + } +} + void CassiniTools::init(bool noGUI, QObject *parent) { if(Q_UNLIKELY(_self==NULL)) @@ -69,13 +86,36 @@ void CassiniTools::plotFile(const QStrin if(!m_dataFile->isRunning()) { m_dataFile->parseFile(File); - QLopPlots::getPlot()->setTitle(File); + // TODO fixme + SocExplorerPlot* plot = QLopPlots::getPlot(m_defaultPlot); + if(plot==NULL) + { + makePlot(); + plot = QLopPlots::getPlot(m_defaultPlot); + } + if(plot) + plot->setTitle(File); } } void CassiniTools::plot_TAB_File(const QString &fileName) { + //TODO fix: accent not accepted + plotFile(fileName); +} +void CassiniTools::export_view() +{ + SocExplorerPlot* plot = QLopPlots::getPlot(m_defaultPlot); + if(plot==NULL) + { + makePlot(); + plot = QLopPlots::getPlot(m_defaultPlot); + } + if(plot) + { + QString fileName = QFileDialog::getSaveFileName(); + } } QDockWidget *CassiniTools::getGUI() @@ -98,19 +138,28 @@ const QString &CassiniTools::serviceName void CassiniTools::dataReady(QLopDataList data) { - QLopPlots::getPlot()->removeAllGraphs(); + SocExplorerPlot* plot = QLopPlots::getPlot(m_defaultPlot); + if(plot==NULL) + { + makePlot(); + plot = QLopPlots::getPlot(m_defaultPlot); + } + if(plot) + { + plot->removeAllGraphs(); for(int i=0;iaddGraph(); - QLopPlots::getPlot()->setAdaptativeSampling(i,true); - QLopPlots::getPlot()->setUseFastVector(i,true); - QPen pen = QLopPlots::getPlot()->getGraphPen(i); + plot->addGraph(); + plot->setAdaptativeSampling(i,true); + plot->setUseFastVector(i,true); + QPen pen = plot->getGraphPen(i); pen.setColor(QLopColours[i%QLopColoursCount]); - QLopPlots::getPlot()->setGraphPen(i,pen); - QLopPlots::getPlot()->setGraphName(i,data.at(i)->name+"("+data.at(i)->unit+")"); - QLopPlots::getPlot()->setGraphData(i,data.at(i)->data,false); + plot->setGraphPen(i,pen); + plot->setGraphName(i,data.at(i)->name+"("+data.at(i)->unit+")"); + plot->setGraphData(i,data.at(i)->data,false); } - QLopPlots::getPlot()->rescaleAxis(); - QLopPlots::getPlot()->replot(); + plot->rescaleAxis(); + plot->replot(); + } } diff --git a/src/Cassini/cassinitools.h b/src/Cassini/cassinitools.h --- a/src/Cassini/cassinitools.h +++ b/src/Cassini/cassinitools.h @@ -7,6 +7,7 @@ #include #include #include +#include class CassiniTools: public QLopService { @@ -16,8 +17,10 @@ private: static QDockWidget* m_gui; static CassiniToolsGUI* m_CassiniToolsGUI; static CassiniDataFile* m_dataFile; + static int m_defaultPlot; CassiniTools(bool noGUI=false, QObject *parent=0); ~CassiniTools(); + static void makePlot(); public: static void init(bool noGUI=false,QObject *parent = 0); static CassiniTools *self(); @@ -28,8 +31,10 @@ public: static void plotFile(const QString &File); public slots: void plot_TAB_File(const QString& fileName); + void export_view(); private slots: void dataReady(QLopDataList data); }; #endif // CASSINITOOLS_H + diff --git a/src/Cassini/cassinitoolsgui.cpp b/src/Cassini/cassinitoolsgui.cpp --- a/src/Cassini/cassinitoolsgui.cpp +++ b/src/Cassini/cassinitoolsgui.cpp @@ -17,16 +17,17 @@ CassiniToolsGUI::~CassiniToolsGUI() void CassiniToolsGUI::addFolderView() { - this->folderViews.append(new FolderView()); - this->ui->folderViews->addDockWidget(Qt::TopDockWidgetArea,this->folderViews.last()); - this->folderViews.last()->setWindowTitle( QString("Folder View %1").arg(this->folderViews.length())); - this->folderViews.last()->setAllowedAreas(Qt::AllDockWidgetAreas); - connect(this->folderViews.last(),SIGNAL(itemActivated(QString)),this,SLOT(plotFile(QString))); + this->fileBrowsers.append(new FileBrowser()); + this->ui->folderViews->addDockWidget(Qt::TopDockWidgetArea,this->fileBrowsers.last()); + this->fileBrowsers.last()->setWindowTitle( QString("Browser %1").arg(this->fileBrowsers.length())); + this->fileBrowsers.last()->setAllowedAreas(Qt::AllDockWidgetAreas); + this->fileBrowsers.last()->setNameFilters(QStringList()<<"*.TAB"); + connect(this->fileBrowsers.last(),SIGNAL(fileDoubleClicked(QString)),this,SLOT(plotFile(QString))); } void CassiniToolsGUI::plotFile(const QString &File) { - CassiniTools::plotFile(File); + CassiniTools::plotFile(File); } void CassiniToolsGUI::changeEvent(QEvent *e) diff --git a/src/Cassini/cassinitoolsgui.h b/src/Cassini/cassinitoolsgui.h --- a/src/Cassini/cassinitoolsgui.h +++ b/src/Cassini/cassinitoolsgui.h @@ -3,6 +3,7 @@ #include #include +#include namespace Ui { class CassiniToolsGUI; @@ -24,7 +25,7 @@ private slots: void plotFile(const QString &File); private: Ui::CassiniToolsGUI *ui; - QList folderViews; + QList fileBrowsers; }; #endif // CASSINITOOLSGUI_H diff --git a/src/Core/Widgets/filebrowser.cpp b/src/Core/Widgets/filebrowser.cpp new file mode 100644 --- /dev/null +++ b/src/Core/Widgets/filebrowser.cpp @@ -0,0 +1,153 @@ +#include "filebrowser.h" +#include "ui_filebrowser.h" +#include +#include + +FileBrowser::FileBrowser(QWidget *parent) : + QDockWidget(parent), + ui(new Ui::FileBrowser) +{ + ui->setupUi(this); + this->model = new FileSystemModel(this); + this->model->setRootPath(QDir::currentPath()); + this->view = new QTreeView(); + this->ui->gridLayout->addWidget(this->view,1,0,1,-1); + this->view->setModel(this->model); + this->cd(model->rootPath()); + connect(this->view,SIGNAL(clicked(QModelIndex)),this,SLOT(clicked(QModelIndex))); + connect(this->view,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(doubleClicked(QModelIndex))); + connect(this->ui->ListViewQpb,SIGNAL(clicked()),this,SLOT(changeToListView())); + connect(this->ui->TreeViewQpb,SIGNAL(clicked()),this,SLOT(changeToTreeView())); + connect(this->ui->parentDirQpb,SIGNAL(clicked()),this,SLOT(parentDir())); + view->setSelectionMode(QAbstractItemView::ExtendedSelection); + view->setDragEnabled(true); + view->setAcceptDrops(true); + view->setDropIndicatorShown(true); + view->setDragDropMode(QAbstractItemView::DragDrop); + this->pathCompleter = new QCompleter(this->model,this); + this->ui->pathLineEdit->setCompleter(pathCompleter); + this->pathLineEditEnterEditMode(false); +} + +FileBrowser::~FileBrowser() +{ + delete ui; +} + +void FileBrowser::setNameFilters(const QStringList &filters,bool disables) +{ + this->model->setNameFilters(filters); + this->model->setNameFilterDisables(disables); +} + +void FileBrowser::changeToTreeView() +{ + this->ui->gridLayout->removeWidget(this->view); + delete this->view; + this->view = new QTreeView(); + this->ui->gridLayout->addWidget(this->view,1,0,1,-1); + this->view->setModel(this->model); + connect(this->view,SIGNAL(clicked(QModelIndex)),this,SLOT(clicked(QModelIndex))); + connect(this->view,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(doubleClicked(QModelIndex))); + this->cd(model->rootPath()); + view->setSelectionMode(QAbstractItemView::ExtendedSelection); + view->setDragEnabled(true); + view->setAcceptDrops(true); + view->setDropIndicatorShown(true); +} + +void FileBrowser::changeToListView() +{ + this->ui->gridLayout->removeWidget(this->view); + delete this->view; + this->view = new QListView(); + this->ui->gridLayout->addWidget(this->view,1,0,1,-1); + this->view->setModel(this->model); + connect(this->view,SIGNAL(clicked(QModelIndex)),this,SLOT(clicked(QModelIndex))); + connect(this->view,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(doubleClicked(QModelIndex))); + this->cd(model->rootPath()); + view->setSelectionMode(QAbstractItemView::ExtendedSelection); + view->setDragEnabled(true); + view->setAcceptDrops(true); + view->setDropIndicatorShown(true); +} + +void FileBrowser::clicked(QModelIndex index) +{ + QString file=model->filePath(index); + if(QFile::exists(file)) + emit fileClicked(file); +} + +void FileBrowser::doubleClicked(QModelIndex index) +{ + if(model->isDir(index)) + { + this->cd(model->filePath(index)); + } + else + { + QString file=model->filePath(index); + if(QFile::exists(file)) + emit fileDoubleClicked(file); + } +} + +void FileBrowser::parentDir() +{ + this->cd(model->rootPath()+"/.."); +} + +void FileBrowser::cd(const QString &newPath) +{ + model->setRootPath(newPath); + this->view->setRootIndex(model->index(model->rootPath())); + this->ui->pathLineEdit->setText(model->rootPath()); +} + + +void FileBrowser::changeEvent(QEvent *e) +{ + QDockWidget::changeEvent(e); + switch (e->type()) { + case QEvent::LanguageChange: + ui->retranslateUi(this); + break; + default: + break; + } +} + +void FileBrowser::keyPressEvent(QKeyEvent *e) +{ + switch (e->key()) + { + case Qt::Key_L: + if(e->modifiers()==Qt::ControlModifier) + { + pathLineEditEnterEditMode(true); + e->accept(); + } + break; + case Qt::Key_Return: + pathLineEditEnterEditMode(false); + if(QFile::exists(this->ui->pathLineEdit->text())) + { + this->cd(this->ui->pathLineEdit->text()); + e->accept(); + } + break; + default: + break; + } + if(!e->isAccepted()) + QDockWidget::keyPressEvent(e); +} + +void FileBrowser::pathLineEditEnterEditMode(bool enter) +{ + this->ui->pathLineEdit->setReadOnly(!enter); + this->ui->pathLineEdit->setDisabled(!enter); + if(enter) + this->ui->pathLineEdit->setFocus(); +} diff --git a/src/Core/Widgets/filebrowser.h b/src/Core/Widgets/filebrowser.h new file mode 100644 --- /dev/null +++ b/src/Core/Widgets/filebrowser.h @@ -0,0 +1,44 @@ +#ifndef FILEBROWSER_H +#define FILEBROWSER_H + +#include +#include +#include +#include +#include +#include + +namespace Ui { +class FileBrowser; +} + +class FileBrowser : public QDockWidget +{ + Q_OBJECT + +public: + explicit FileBrowser(QWidget *parent = 0); + ~FileBrowser(); + void setNameFilters(const QStringList & filters, bool disables=false); +signals: + void fileClicked(const QString& file); + void fileDoubleClicked(const QString& file); +private slots: + void changeToTreeView(); + void changeToListView(); + void clicked(QModelIndex index); + void doubleClicked(QModelIndex index); + void parentDir(); + void cd(const QString& newPath); +protected: + void changeEvent(QEvent *e); + void keyPressEvent(QKeyEvent *e); +private: + void pathLineEditEnterEditMode(bool enter=true); + Ui::FileBrowser *ui; + FileSystemModel* model; + QAbstractItemView* view; + QCompleter* pathCompleter; +}; + +#endif // FILEBROWSER_H diff --git a/src/Core/Widgets/filebrowser.ui b/src/Core/Widgets/filebrowser.ui new file mode 100644 --- /dev/null +++ b/src/Core/Widgets/filebrowser.ui @@ -0,0 +1,90 @@ + + + FileBrowser + + + + 0 + 0 + 685 + 469 + + + + DockWidget + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + + :/img/Gnome-go-up.svg:/img/Gnome-go-up.svg + + + + + + + + + + + :/img/ListView.svg:/img/ListView.svg + + + + + + + + + + + :/img/TreeView.svg:/img/TreeView.svg + + + false + + + false + + + false + + + false + + + + + + + true + + + + + + + + + + + diff --git a/src/Core/Widgets/filesystemmodel.cpp b/src/Core/Widgets/filesystemmodel.cpp new file mode 100644 --- /dev/null +++ b/src/Core/Widgets/filesystemmodel.cpp @@ -0,0 +1,25 @@ +#include "filesystemmodel.h" +FileSystemModel::FileSystemModel(QObject *parent):QFileSystemModel(parent) +{ + this->setReadOnly(false); +} + +FileSystemModel::~FileSystemModel() +{ +} + +Qt::DropActions FileSystemModel::supportedDropActions() const +{ + return Qt::MoveAction; +} + + +Qt::ItemFlags FileSystemModel::flags(const QModelIndex &index) const +{ + Qt::ItemFlags defaultFlags = QFileSystemModel::flags(index); + defaultFlags &= ~Qt::ItemIsEditable; + if (index.isValid()) + return Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | defaultFlags; + else + return Qt::ItemIsDropEnabled | defaultFlags; +} diff --git a/src/Core/Widgets/filesystemmodel.h b/src/Core/Widgets/filesystemmodel.h new file mode 100644 --- /dev/null +++ b/src/Core/Widgets/filesystemmodel.h @@ -0,0 +1,16 @@ +#ifndef FILESYSTEMMODEL_H +#define FILESYSTEMMODEL_H + +#include +#include + +class FileSystemModel : public QFileSystemModel +{ +public: + FileSystemModel(QObject* parent=0); + ~FileSystemModel(); + Qt::DropActions supportedDropActions() const; + Qt::ItemFlags flags(const QModelIndex &index) const; +}; + +#endif // FILESYSTEMMODEL_H diff --git a/src/Core/Widgets/qlopplots.cpp b/src/Core/Widgets/qlopplots.cpp --- a/src/Core/Widgets/qlopplots.cpp +++ b/src/Core/Widgets/qlopplots.cpp @@ -1,8 +1,12 @@ #include "qlopplots.h" +#include QLopPlots* QLopPlots::_self=NULL; -SocExplorerPlot* QLopPlots::m_SocExplorerPlot=NULL; +SocExplorerPlot* QLopPlots::m_LastPlot=NULL; QDockWidget* QLopPlots::m_gui=NULL; +QHash* QLopPlots::m_plots=NULL; +toolBarContainer* QLopPlots::m_DocContainer=NULL; + #define _INIT() if(Q_UNLIKELY(_self==NULL)){init();} @@ -11,6 +15,7 @@ QLopPlots::QLopPlots(bool noGUI,QObject { m_noGui = noGUI; m_serviceName = "QLopPlots"; + m_plots = new QHash(); } QLopPlots::~QLopPlots() @@ -18,6 +23,19 @@ QLopPlots::~QLopPlots() } +int QLopPlots::getPlotID() +{ + _INIT(); + for(int i=0;i<32768;i++) + { + if(!m_plots->contains(i)) + { + return i; + } + } + return -1; +} + void QLopPlots::init(bool noGUI, QObject *parent) { if(Q_UNLIKELY(_self==NULL)) @@ -32,17 +50,71 @@ QLopPlots *QLopPlots::self() return _self; } -SocExplorerPlot *QLopPlots::getPlot() +SocExplorerPlot *QLopPlots::getPlot(int plotID) { _INIT(); if(!_self->m_noGui && (m_gui==NULL)) { m_gui=new QDockWidget("Plots"); - m_SocExplorerPlot = new SocExplorerPlot(); - m_gui->setWidget(m_SocExplorerPlot); + m_DocContainer = new toolBarContainer(); +// m_SocExplorerPlot = new SocExplorerPlot(); + m_gui->setWidget(m_DocContainer); m_gui->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable); } - return m_SocExplorerPlot; + if(m_plots->contains(plotID)) + { + return m_plots->value(plotID); + } + if(plotID==-1) + { + return m_LastPlot; + } + return NULL; +} + +int QLopPlots::addPlot() +{ + _INIT(); + int pid=getPlotID(); + if(pid!=-1) + { + SocExplorerPlot* plot=new SocExplorerPlot(); + m_plots->insert(pid,plot); + QDockWidget* dock = new QDockWidget(); + dock->setWidget(plot); + dock->setAllowedAreas(Qt::AllDockWidgetAreas); + m_DocContainer->addDockWidget(Qt::TopDockWidgetArea,dock); + m_LastPlot=plot; + QObject::connect(plot,SIGNAL(titleChanged(QString)),dock,SLOT(setWindowTitle(QString))); + plot->setTitle(QString("Plot %1").arg(pid)); + } + return pid; +} + +bool QLopPlots::removePlot(int plotID) +{ + _INIT(); + if(m_plots->contains(plotID)) + { + SocExplorerPlot* plot=m_plots->value(plotID); + m_plots->remove(plotID); + QDockWidget* dock=(QDockWidget*)plot->parentWidget(); + m_DocContainer->removeDockWidget(dock); + if(plot==m_LastPlot) + { + //TODO may cause troubles... + m_LastPlot = NULL; + } + if(dock!=NULL) + { + delete dock; + } + if(plot!=NULL) + { + delete plot; + } + } + return false; } QDockWidget *QLopPlots::getGUI() @@ -50,8 +122,9 @@ QDockWidget *QLopPlots::getGUI() if(!m_noGui && (m_gui==NULL)) { m_gui=new QDockWidget("Plots"); - m_SocExplorerPlot = new SocExplorerPlot(); - m_gui->setWidget(m_SocExplorerPlot); + m_DocContainer = new toolBarContainer(); +// m_SocExplorerPlot = new SocExplorerPlot(); + m_gui->setWidget(m_DocContainer); m_gui->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable); } return m_gui; @@ -62,8 +135,18 @@ const QString &QLopPlots::serviceName() return m_serviceName; } -SocExplorerPlot *QLopPlots::get_plot() +SocExplorerPlot *QLopPlots::get_plot(int plotID) { - return getPlot(); + return getPlot(plotID); } +int QLopPlots::add_plot() +{ + return addPlot(); +} + +bool QLopPlots::remove_plot(int plotID) +{ + return removePlot(plotID); +} + diff --git a/src/Core/Widgets/qlopplots.h b/src/Core/Widgets/qlopplots.h --- a/src/Core/Widgets/qlopplots.h +++ b/src/Core/Widgets/qlopplots.h @@ -5,26 +5,36 @@ #include #include #include +#include +#include +#include class QLopPlots: public QLopService { Q_OBJECT private: static QLopPlots* _self; - static SocExplorerPlot* m_SocExplorerPlot; + static SocExplorerPlot* m_LastPlot; + static QHash* m_plots; static QDockWidget* m_gui; + static toolBarContainer* m_DocContainer; QLopPlots(bool noGUI=false,QObject *parent = 0); ~QLopPlots(); + static int getPlotID(); public: static void init(bool noGUI=false,QObject *parent = 0); static QLopPlots *self(); - static SocExplorerPlot* getPlot(); + static SocExplorerPlot* getPlot(int plotID=-1); + static int addPlot(); + static bool removePlot(int plotID); // QLopService methodes QDockWidget* getGUI(); const QString& serviceName(); public slots: - SocExplorerPlot* get_plot(); + SocExplorerPlot* get_plot(int plotID); + int add_plot(); + bool remove_plot(int plotID); public: }; diff --git a/src/Core/pyqlop.h b/src/Core/pyqlop.h --- a/src/Core/pyqlop.h +++ b/src/Core/pyqlop.h @@ -5,6 +5,9 @@ #include "qlopservice.h" #include "qlopdata.h" #include "SocExplorerPlot.h" +#include "filebrowser.h" +#include "qlopdata.h" +#include "qcustomplot.h" #endif // PYQLOP diff --git a/src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop0.cpp b/src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop0.cpp --- a/src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop0.cpp +++ b/src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop0.cpp @@ -3,40 +3,9452 @@ #include #include #include +#include #include #include #include +#include #include +#include #include #include +#include #include #include #include +#include +#include +#include #include #include #include +#include #include #include +#include #include #include +#include #include +#include #include #include #include #include #include +#include #include #include +#include #include #include +#include #include #include #include #include +#include +#include #include +#include +#include +#include +#include #include #include +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 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 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" , "bool"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + QList 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*)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 PythonQtWrapper_QCPAxis::graphs(QCPAxis* theWrappedObject) const +{ + return ( theWrappedObject->graphs()); +} + +QList 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& vec) +{ + ( theWrappedObject->setTickVector(vec)); +} + +void PythonQtWrapper_QCPAxis::setTickVectorLabels(QCPAxis* theWrappedObject, const QVector& 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 PythonQtWrapper_QCPAxis::tickVector(QCPAxis* theWrappedObject) const +{ + return ( theWrappedObject->tickVector()); +} + +QVector 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 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" , "bool"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + QList 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*)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 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 PythonQtWrapper_QCPAxisRect::elements(QCPAxisRect* theWrappedObject, bool recursive) const +{ + return ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_elements(recursive)); +} + +QList PythonQtWrapper_QCPAxisRect::graphs(QCPAxisRect* theWrappedObject) const +{ + return ( theWrappedObject->graphs()); +} + +int PythonQtWrapper_QCPAxisRect::height(QCPAxisRect* theWrappedObject) const +{ + return ( theWrappedObject->height()); +} + +QList 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& keys, const QVector& 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& key, const QVector& 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 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" , "bool"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + QList 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*)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 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* 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*"}; + 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* 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*"}; + 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* 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*"}; + 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& keys, const QVector& 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* 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* lineData) const +{ + ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawFill(painter, lineData)); +} + +void PythonQtWrapper_QCPGraph::drawImpulsePlot(QCPGraph* theWrappedObject, QCPPainter* painter, QVector* 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* 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* data, double x) const +{ + return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexAboveX(data, x)); +} + +int PythonQtWrapper_QCPGraph::findIndexAboveY(QCPGraph* theWrappedObject, const QVector* data, double y) const +{ + return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexAboveY(data, y)); +} + +int PythonQtWrapper_QCPGraph::findIndexBelowX(QCPGraph* theWrappedObject, const QVector* data, double x) const +{ + return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexBelowX(data, x)); +} + +int PythonQtWrapper_QCPGraph::findIndexBelowY(QCPGraph* theWrappedObject, const QVector* data, double y) const +{ + return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexBelowY(data, y)); +} + +const QPolygonF PythonQtWrapper_QCPGraph::getChannelFillPolygon(QCPGraph* theWrappedObject, const QVector* 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* 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& key, const QVector& value) +{ + ( theWrappedObject->setData(key, value)); +} + +void PythonQtWrapper_QCPGraph::setDataBothError(QCPGraph* theWrappedObject, const QVector& key, const QVector& value, const QVector& keyError, const QVector& valueError) +{ + ( theWrappedObject->setDataBothError(key, value, keyError, valueError)); +} + +void PythonQtWrapper_QCPGraph::setDataBothError(QCPGraph* theWrappedObject, const QVector& key, const QVector& value, const QVector& keyErrorMinus, const QVector& keyErrorPlus, const QVector& valueErrorMinus, const QVector& valueErrorPlus) +{ + ( theWrappedObject->setDataBothError(key, value, keyErrorMinus, keyErrorPlus, valueErrorMinus, valueErrorPlus)); +} + +void PythonQtWrapper_QCPGraph::setDataKeyError(QCPGraph* theWrappedObject, const QVector& key, const QVector& value, const QVector& keyError) +{ + ( theWrappedObject->setDataKeyError(key, value, keyError)); +} + +void PythonQtWrapper_QCPGraph::setDataKeyError(QCPGraph* theWrappedObject, const QVector& key, const QVector& value, const QVector& keyErrorMinus, const QVector& keyErrorPlus) +{ + ( theWrappedObject->setDataKeyError(key, value, keyErrorMinus, keyErrorPlus)); +} + +void PythonQtWrapper_QCPGraph::setDataValueError(QCPGraph* theWrappedObject, const QVector& key, const QVector& value, const QVector& valueError) +{ + ( theWrappedObject->setDataValueError(key, value, valueError)); +} + +void PythonQtWrapper_QCPGraph::setDataValueError(QCPGraph* theWrappedObject, const QVector& key, const QVector& value, const QVector& valueErrorMinus, const QVector& 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 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 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" , "bool"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + QList 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*)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 PythonQtWrapper_QCPLayout::elements(QCPLayout* theWrappedObject, bool recursive) const +{ + return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_elements(recursive)); +} + +QVector PythonQtWrapper_QCPLayout::getSectionSizes(QCPLayout* theWrappedObject, QVector maxSizes, QVector minSizes, QVector 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 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" , "bool"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + QList 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*)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 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 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 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" , "bool"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + QList 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*)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 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 PythonQtWrapper_QCustomPlot::selectedAxes(QCustomPlot* theWrappedObject) const +{ + return ( theWrappedObject->selectedAxes()); +} + +QList PythonQtWrapper_QCustomPlot::selectedGraphs(QCustomPlot* theWrappedObject) const +{ + return ( theWrappedObject->selectedGraphs()); +} + +QList PythonQtWrapper_QCustomPlot::selectedItems(QCustomPlot* theWrappedObject) const +{ + return ( theWrappedObject->selectedItems()); +} + +QList 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& l) +{ +return new QLopDataList(l); } + +void PythonQtWrapper_QLopDataList::append(QLopDataList* theWrappedObject, QLopData* t) +{ + ( theWrappedObject->append(t)); +} + +void PythonQtWrapper_QLopDataList::append(QLopDataList* theWrappedObject, const QList& 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 PythonQtWrapper_QLopDataList::static_QLopDataList_fromVector(const QVector& 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& 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 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& l) const +{ + return ( (*theWrappedObject)!= l); +} + +QList PythonQtWrapper_QLopDataList::__add__(QLopDataList* theWrappedObject, const QList& l) const +{ + return ( (*theWrappedObject)+ l); +} + +QList* PythonQtWrapper_QLopDataList::__iadd__(QLopDataList* theWrappedObject, QLopData* t) +{ + return &( (*theWrappedObject)+= t); +} + +QList* PythonQtWrapper_QLopDataList::__iadd__(QLopDataList* theWrappedObject, const QList& l) +{ + return &( (*theWrappedObject)+= l); +} + +QList* PythonQtWrapper_QLopDataList::__lshift__(QLopDataList* theWrappedObject, QLopData* t) +{ + return &( (*theWrappedObject) <* PythonQtWrapper_QLopDataList::__lshift__(QLopDataList* theWrappedObject, const QList& l) +{ + return &( (*theWrappedObject) <& 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& 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 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)); +} + + + PythonQtShell_QLopService::~PythonQtShell_QLopService() { PythonQtPrivate* priv = PythonQt::priv(); if (priv) { priv->shellClassDeleted(this); } diff --git a/src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop0.h b/src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop0.h --- a/src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop0.h +++ b/src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop0.h @@ -2,43 +2,1598 @@ #include #include #include +#include +#include #include #include #include +#include #include +#include #include #include +#include #include #include #include +#include +#include +#include #include #include #include +#include #include #include +#include #include #include +#include #include #include +#include #include #include #include #include #include +#include #include #include +#include #include #include +#include #include #include #include #include +#include +#include #include +#include +#include +#include +#include #include #include +class PythonQtShell_FileBrowser : public FileBrowser +{ +public: + PythonQtShell_FileBrowser(QWidget* parent = 0):FileBrowser(parent),_wrapper(NULL) { }; + + ~PythonQtShell_FileBrowser(); + +virtual void actionEvent(QActionEvent* arg__1); +virtual void changeEvent(QEvent* e); +virtual void childEvent(QChildEvent* arg__1); +virtual void closeEvent(QCloseEvent* event); +virtual void contextMenuEvent(QContextMenuEvent* arg__1); +virtual void customEvent(QEvent* arg__1); +virtual int devType() const; +virtual void dragEnterEvent(QDragEnterEvent* arg__1); +virtual void dragLeaveEvent(QDragLeaveEvent* arg__1); +virtual void dragMoveEvent(QDragMoveEvent* arg__1); +virtual void dropEvent(QDropEvent* arg__1); +virtual void enterEvent(QEvent* arg__1); +virtual bool event(QEvent* event); +virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); +virtual void focusInEvent(QFocusEvent* arg__1); +virtual bool focusNextPrevChild(bool next); +virtual void focusOutEvent(QFocusEvent* arg__1); +virtual bool hasHeightForWidth() const; +virtual int heightForWidth(int arg__1) const; +virtual void hideEvent(QHideEvent* arg__1); +virtual void initPainter(QPainter* painter) const; +virtual void inputMethodEvent(QInputMethodEvent* arg__1); +virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const; +virtual void keyPressEvent(QKeyEvent* e); +virtual void keyReleaseEvent(QKeyEvent* arg__1); +virtual void leaveEvent(QEvent* arg__1); +virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const; +virtual QSize minimumSizeHint() const; +virtual void mouseDoubleClickEvent(QMouseEvent* arg__1); +virtual void mouseMoveEvent(QMouseEvent* arg__1); +virtual void mousePressEvent(QMouseEvent* arg__1); +virtual void mouseReleaseEvent(QMouseEvent* arg__1); +virtual void moveEvent(QMoveEvent* arg__1); +virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result); +virtual QPaintEngine* paintEngine() const; +virtual void paintEvent(QPaintEvent* event); +virtual QPaintDevice* redirected(QPoint* offset) const; +virtual void resizeEvent(QResizeEvent* arg__1); +virtual QPainter* sharedPainter() const; +virtual void showEvent(QShowEvent* arg__1); +virtual QSize sizeHint() const; +virtual void tabletEvent(QTabletEvent* arg__1); +virtual void timerEvent(QTimerEvent* arg__1); +virtual void wheelEvent(QWheelEvent* arg__1); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_FileBrowser : public FileBrowser +{ public: +inline void promoted_changeEvent(QEvent* e) { FileBrowser::changeEvent(e); } +inline void promoted_keyPressEvent(QKeyEvent* e) { FileBrowser::keyPressEvent(e); } +}; + +class PythonQtWrapper_FileBrowser : public QObject +{ Q_OBJECT +public: +public slots: +FileBrowser* new_FileBrowser(QWidget* parent = 0); +void delete_FileBrowser(FileBrowser* obj) { delete obj; } + void changeEvent(FileBrowser* theWrappedObject, QEvent* e); + void keyPressEvent(FileBrowser* theWrappedObject, QKeyEvent* e); + void setNameFilters(FileBrowser* theWrappedObject, const QStringList& filters, bool disables = false); +}; + + + + + +class PythonQtShell_QCPAbstractItem : public QCPAbstractItem +{ +public: + PythonQtShell_QCPAbstractItem(QCustomPlot* parentPlot):QCPAbstractItem(parentPlot),_wrapper(NULL) { }; + + ~PythonQtShell_QCPAbstractItem(); + +virtual QPointF anchorPixelPoint(int anchorId) const; +virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const; +virtual void childEvent(QChildEvent* arg__1); +virtual QRect clipRect() const; +virtual void customEvent(QEvent* arg__1); +virtual void deselectEvent(bool* selectionStateChanged); +virtual void draw(QCPPainter* painter); +virtual bool event(QEvent* arg__1); +virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); +virtual void parentPlotInitialized(QCustomPlot* parentPlot); +virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); +virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; +virtual void timerEvent(QTimerEvent* arg__1); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPAbstractItem : public QCPAbstractItem +{ public: +inline QPointF promoted_anchorPixelPoint(int anchorId) const { return QCPAbstractItem::anchorPixelPoint(anchorId); } +inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPAbstractItem::applyDefaultAntialiasingHint(painter); } +inline QRect promoted_clipRect() const { return QCPAbstractItem::clipRect(); } +inline QCPItemPosition* promoted_createPosition(const QString& name) { return QCPAbstractItem::createPosition(name); } +inline void promoted_deselectEvent(bool* selectionStateChanged) { QCPAbstractItem::deselectEvent(selectionStateChanged); } +inline double promoted_distSqrToLine(const QPointF& start, const QPointF& end, const QPointF& point) const { return QCPAbstractItem::distSqrToLine(start, end, point); } +inline void promoted_draw(QCPPainter* painter) { draw(painter); } +inline double promoted_rectSelectTest(const QRectF& rect, const QPointF& pos, bool filledRect) const { return QCPAbstractItem::rectSelectTest(rect, pos, filledRect); } +inline void promoted_selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) { QCPAbstractItem::selectEvent(event, additive, details, selectionStateChanged); } +inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return selectTest(pos, onlySelectable, details); } +}; + +class PythonQtWrapper_QCPAbstractItem : public QObject +{ Q_OBJECT +public: +public slots: +QCPAbstractItem* new_QCPAbstractItem(QCustomPlot* parentPlot); +void delete_QCPAbstractItem(QCPAbstractItem* obj) { delete obj; } + QPointF anchorPixelPoint(QCPAbstractItem* theWrappedObject, int anchorId) const; + void applyDefaultAntialiasingHint(QCPAbstractItem* theWrappedObject, QCPPainter* painter) const; + QCPAxisRect* clipAxisRect(QCPAbstractItem* theWrappedObject) const; + QRect clipRect(QCPAbstractItem* theWrappedObject) const; + bool clipToAxisRect(QCPAbstractItem* theWrappedObject) const; + QCPItemPosition* createPosition(QCPAbstractItem* theWrappedObject, const QString& name); + void deselectEvent(QCPAbstractItem* theWrappedObject, bool* selectionStateChanged); + double distSqrToLine(QCPAbstractItem* theWrappedObject, const QPointF& start, const QPointF& end, const QPointF& point) const; + void draw(QCPAbstractItem* theWrappedObject, QCPPainter* painter); + bool hasAnchor(QCPAbstractItem* theWrappedObject, const QString& name) const; + QCPItemPosition* position(QCPAbstractItem* theWrappedObject, const QString& name) const; + QList positions(QCPAbstractItem* theWrappedObject) const; + double rectSelectTest(QCPAbstractItem* theWrappedObject, const QRectF& rect, const QPointF& pos, bool filledRect) const; + void selectEvent(QCPAbstractItem* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); + double selectTest(QCPAbstractItem* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + bool selectable(QCPAbstractItem* theWrappedObject) const; + bool selected(QCPAbstractItem* theWrappedObject) const; + void setClipAxisRect(QCPAbstractItem* theWrappedObject, QCPAxisRect* rect); + void setClipToAxisRect(QCPAbstractItem* theWrappedObject, bool clip); + void setSelectable(QCPAbstractItem* theWrappedObject, bool selectable); + void setSelected(QCPAbstractItem* theWrappedObject, bool selected); +}; + + + + + +class PythonQtShell_QCPAbstractLegendItem : public QCPAbstractLegendItem +{ +public: + PythonQtShell_QCPAbstractLegendItem(QCPLegend* parent):QCPAbstractLegendItem(parent),_wrapper(NULL) { }; + + ~PythonQtShell_QCPAbstractLegendItem(); + +virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const; +virtual void childEvent(QChildEvent* arg__1); +virtual QRect clipRect() const; +virtual void customEvent(QEvent* arg__1); +virtual void deselectEvent(bool* selectionStateChanged); +virtual void draw(QCPPainter* painter); +virtual QList elements(bool recursive) const; +virtual bool event(QEvent* arg__1); +virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); +virtual QSize maximumSizeHint() const; +virtual QSize minimumSizeHint() const; +virtual void mouseDoubleClickEvent(QMouseEvent* event); +virtual void mouseMoveEvent(QMouseEvent* event); +virtual void mousePressEvent(QMouseEvent* event); +virtual void mouseReleaseEvent(QMouseEvent* event); +virtual void parentPlotInitialized(QCustomPlot* parentPlot); +virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); +virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; +virtual void timerEvent(QTimerEvent* arg__1); +virtual void wheelEvent(QWheelEvent* event); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPAbstractLegendItem : public QCPAbstractLegendItem +{ public: +inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPAbstractLegendItem::applyDefaultAntialiasingHint(painter); } +inline QRect promoted_clipRect() const { return QCPAbstractLegendItem::clipRect(); } +inline void promoted_deselectEvent(bool* selectionStateChanged) { QCPAbstractLegendItem::deselectEvent(selectionStateChanged); } +inline void promoted_draw(QCPPainter* painter) { draw(painter); } +inline void promoted_selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) { QCPAbstractLegendItem::selectEvent(event, additive, details, selectionStateChanged); } +inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPAbstractLegendItem::selectTest(pos, onlySelectable, details); } +}; + +class PythonQtWrapper_QCPAbstractLegendItem : public QObject +{ Q_OBJECT +public: +public slots: +QCPAbstractLegendItem* new_QCPAbstractLegendItem(QCPLegend* parent); +void delete_QCPAbstractLegendItem(QCPAbstractLegendItem* obj) { delete obj; } + void applyDefaultAntialiasingHint(QCPAbstractLegendItem* theWrappedObject, QCPPainter* painter) const; + QRect clipRect(QCPAbstractLegendItem* theWrappedObject) const; + void deselectEvent(QCPAbstractLegendItem* theWrappedObject, bool* selectionStateChanged); + void draw(QCPAbstractLegendItem* theWrappedObject, QCPPainter* painter); + QFont font(QCPAbstractLegendItem* theWrappedObject) const; + QCPLegend* parentLegend(QCPAbstractLegendItem* theWrappedObject) const; + void selectEvent(QCPAbstractLegendItem* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); + double selectTest(QCPAbstractLegendItem* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + bool selectable(QCPAbstractLegendItem* theWrappedObject) const; + bool selected(QCPAbstractLegendItem* theWrappedObject) const; + QFont selectedFont(QCPAbstractLegendItem* theWrappedObject) const; + QColor selectedTextColor(QCPAbstractLegendItem* theWrappedObject) const; + void setFont(QCPAbstractLegendItem* theWrappedObject, const QFont& font); + void setSelectable(QCPAbstractLegendItem* theWrappedObject, bool selectable); + void setSelected(QCPAbstractLegendItem* theWrappedObject, bool selected); + void setSelectedFont(QCPAbstractLegendItem* theWrappedObject, const QFont& font); + void setSelectedTextColor(QCPAbstractLegendItem* theWrappedObject, const QColor& color); + void setTextColor(QCPAbstractLegendItem* theWrappedObject, const QColor& color); + QColor textColor(QCPAbstractLegendItem* theWrappedObject) const; +}; + + + + + +class PythonQtPublicPromoter_QCPAxis : public QCPAxis +{ public: +inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPAxis::applyDefaultAntialiasingHint(painter); } +inline double promoted_baseLog(double value) const { return QCPAxis::baseLog(value); } +inline double promoted_basePow(double value) const { return QCPAxis::basePow(value); } +inline int promoted_calculateAutoSubTickCount(double tickStep) const { return QCPAxis::calculateAutoSubTickCount(tickStep); } +inline int promoted_calculateMargin() { return QCPAxis::calculateMargin(); } +inline void promoted_deselectEvent(bool* selectionStateChanged) { QCPAxis::deselectEvent(selectionStateChanged); } +inline void promoted_draw(QCPPainter* painter) { QCPAxis::draw(painter); } +inline void promoted_generateAutoTicks() { QCPAxis::generateAutoTicks(); } +inline QPen promoted_getBasePen() const { return QCPAxis::getBasePen(); } +inline QColor promoted_getLabelColor() const { return QCPAxis::getLabelColor(); } +inline QFont promoted_getLabelFont() const { return QCPAxis::getLabelFont(); } +inline QPen promoted_getSubTickPen() const { return QCPAxis::getSubTickPen(); } +inline QColor promoted_getTickLabelColor() const { return QCPAxis::getTickLabelColor(); } +inline QFont promoted_getTickLabelFont() const { return QCPAxis::getTickLabelFont(); } +inline QPen promoted_getTickPen() const { return QCPAxis::getTickPen(); } +inline void promoted_selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) { QCPAxis::selectEvent(event, additive, details, selectionStateChanged); } +inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPAxis::selectTest(pos, onlySelectable, details); } +inline void promoted_setupTickVectors() { QCPAxis::setupTickVectors(); } +inline void promoted_visibleTickBounds(int& lowIndex, int& highIndex) const { QCPAxis::visibleTickBounds(lowIndex, highIndex); } +}; + +class PythonQtWrapper_QCPAxis : public QObject +{ Q_OBJECT +public: +public slots: +void delete_QCPAxis(QCPAxis* obj) { delete obj; } + void applyDefaultAntialiasingHint(QCPAxis* theWrappedObject, QCPPainter* painter) const; + bool autoSubTicks(QCPAxis* theWrappedObject) const; + int autoTickCount(QCPAxis* theWrappedObject) const; + bool autoTickLabels(QCPAxis* theWrappedObject) const; + bool autoTickStep(QCPAxis* theWrappedObject) const; + bool autoTicks(QCPAxis* theWrappedObject) const; + QCPAxisRect* axisRect(QCPAxis* theWrappedObject) const; + double baseLog(QCPAxis* theWrappedObject, double value) const; + QPen basePen(QCPAxis* theWrappedObject) const; + double basePow(QCPAxis* theWrappedObject, double value) const; + int calculateAutoSubTickCount(QCPAxis* theWrappedObject, double tickStep) const; + int calculateMargin(QCPAxis* theWrappedObject); + double coordToPixel(QCPAxis* theWrappedObject, double value) const; + QString dateTimeFormat(QCPAxis* theWrappedObject) const; + Qt::TimeSpec dateTimeSpec(QCPAxis* theWrappedObject) const; + void deselectEvent(QCPAxis* theWrappedObject, bool* selectionStateChanged); + void draw(QCPAxis* theWrappedObject, QCPPainter* painter); + void generateAutoTicks(QCPAxis* theWrappedObject); + QPen getBasePen(QCPAxis* theWrappedObject) const; + QColor getLabelColor(QCPAxis* theWrappedObject) const; + QFont getLabelFont(QCPAxis* theWrappedObject) const; + QPen getSubTickPen(QCPAxis* theWrappedObject) const; + QColor getTickLabelColor(QCPAxis* theWrappedObject) const; + QFont getTickLabelFont(QCPAxis* theWrappedObject) const; + QPen getTickPen(QCPAxis* theWrappedObject) const; + QList graphs(QCPAxis* theWrappedObject) const; + QList items(QCPAxis* theWrappedObject) const; + QString label(QCPAxis* theWrappedObject) const; + QColor labelColor(QCPAxis* theWrappedObject) const; + QFont labelFont(QCPAxis* theWrappedObject) const; + int labelPadding(QCPAxis* theWrappedObject) const; + void moveRange(QCPAxis* theWrappedObject, double diff); + QString numberFormat(QCPAxis* theWrappedObject) const; + int numberPrecision(QCPAxis* theWrappedObject) const; + int offset(QCPAxis* theWrappedObject) const; + Qt::Orientation orientation(QCPAxis* theWrappedObject) const; + int padding(QCPAxis* theWrappedObject) const; + double pixelToCoord(QCPAxis* theWrappedObject, double value) const; + bool rangeReversed(QCPAxis* theWrappedObject) const; + void rescale(QCPAxis* theWrappedObject, bool onlyVisiblePlottables = false); + double scaleLogBase(QCPAxis* theWrappedObject) const; + void scaleRange(QCPAxis* theWrappedObject, double factor, double center); + void selectEvent(QCPAxis* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); + double selectTest(QCPAxis* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + QPen selectedBasePen(QCPAxis* theWrappedObject) const; + QColor selectedLabelColor(QCPAxis* theWrappedObject) const; + QFont selectedLabelFont(QCPAxis* theWrappedObject) const; + QPen selectedSubTickPen(QCPAxis* theWrappedObject) const; + QColor selectedTickLabelColor(QCPAxis* theWrappedObject) const; + QFont selectedTickLabelFont(QCPAxis* theWrappedObject) const; + QPen selectedTickPen(QCPAxis* theWrappedObject) const; + void setAutoSubTicks(QCPAxis* theWrappedObject, bool on); + void setAutoTickCount(QCPAxis* theWrappedObject, int approximateCount); + void setAutoTickLabels(QCPAxis* theWrappedObject, bool on); + void setAutoTickStep(QCPAxis* theWrappedObject, bool on); + void setAutoTicks(QCPAxis* theWrappedObject, bool on); + void setBasePen(QCPAxis* theWrappedObject, const QPen& pen); + void setDateTimeFormat(QCPAxis* theWrappedObject, const QString& format); + void setDateTimeSpec(QCPAxis* theWrappedObject, const Qt::TimeSpec& timeSpec); + void setLabel(QCPAxis* theWrappedObject, const QString& str); + void setLabelColor(QCPAxis* theWrappedObject, const QColor& color); + void setLabelFont(QCPAxis* theWrappedObject, const QFont& font); + void setLabelPadding(QCPAxis* theWrappedObject, int padding); + void setNumberFormat(QCPAxis* theWrappedObject, const QString& formatCode); + void setNumberPrecision(QCPAxis* theWrappedObject, int precision); + void setOffset(QCPAxis* theWrappedObject, int offset); + void setPadding(QCPAxis* theWrappedObject, int padding); + void setRange(QCPAxis* theWrappedObject, double lower, double upper); + void setRange(QCPAxis* theWrappedObject, double position, double size, Qt::AlignmentFlag alignment); + void setRangeLower(QCPAxis* theWrappedObject, double lower); + void setRangeReversed(QCPAxis* theWrappedObject, bool reversed); + void setRangeUpper(QCPAxis* theWrappedObject, double upper); + void setScaleLogBase(QCPAxis* theWrappedObject, double base); + void setScaleRatio(QCPAxis* theWrappedObject, const QCPAxis* otherAxis, double ratio = 1.0); + void setSelectedBasePen(QCPAxis* theWrappedObject, const QPen& pen); + void setSelectedLabelColor(QCPAxis* theWrappedObject, const QColor& color); + void setSelectedLabelFont(QCPAxis* theWrappedObject, const QFont& font); + void setSelectedSubTickPen(QCPAxis* theWrappedObject, const QPen& pen); + void setSelectedTickLabelColor(QCPAxis* theWrappedObject, const QColor& color); + void setSelectedTickLabelFont(QCPAxis* theWrappedObject, const QFont& font); + void setSelectedTickPen(QCPAxis* theWrappedObject, const QPen& pen); + void setSubTickCount(QCPAxis* theWrappedObject, int count); + void setSubTickLength(QCPAxis* theWrappedObject, int inside, int outside = 0); + void setSubTickLengthIn(QCPAxis* theWrappedObject, int inside); + void setSubTickLengthOut(QCPAxis* theWrappedObject, int outside); + void setSubTickPen(QCPAxis* theWrappedObject, const QPen& pen); + void setTickLabelColor(QCPAxis* theWrappedObject, const QColor& color); + void setTickLabelFont(QCPAxis* theWrappedObject, const QFont& font); + void setTickLabelPadding(QCPAxis* theWrappedObject, int padding); + void setTickLabelRotation(QCPAxis* theWrappedObject, double degrees); + void setTickLabels(QCPAxis* theWrappedObject, bool show); + void setTickLength(QCPAxis* theWrappedObject, int inside, int outside = 0); + void setTickLengthIn(QCPAxis* theWrappedObject, int inside); + void setTickLengthOut(QCPAxis* theWrappedObject, int outside); + void setTickPen(QCPAxis* theWrappedObject, const QPen& pen); + void setTickStep(QCPAxis* theWrappedObject, double step); + void setTickVector(QCPAxis* theWrappedObject, const QVector& vec); + void setTickVectorLabels(QCPAxis* theWrappedObject, const QVector& vec); + void setTicks(QCPAxis* theWrappedObject, bool show); + void setupTickVectors(QCPAxis* theWrappedObject); + int subTickCount(QCPAxis* theWrappedObject) const; + int subTickLengthIn(QCPAxis* theWrappedObject) const; + int subTickLengthOut(QCPAxis* theWrappedObject) const; + QPen subTickPen(QCPAxis* theWrappedObject) const; + QColor tickLabelColor(QCPAxis* theWrappedObject) const; + QFont tickLabelFont(QCPAxis* theWrappedObject) const; + int tickLabelPadding(QCPAxis* theWrappedObject) const; + double tickLabelRotation(QCPAxis* theWrappedObject) const; + bool tickLabels(QCPAxis* theWrappedObject) const; + int tickLengthIn(QCPAxis* theWrappedObject) const; + int tickLengthOut(QCPAxis* theWrappedObject) const; + QPen tickPen(QCPAxis* theWrappedObject) const; + double tickStep(QCPAxis* theWrappedObject) const; + QVector tickVector(QCPAxis* theWrappedObject) const; + QVector tickVectorLabels(QCPAxis* theWrappedObject) const; + bool ticks(QCPAxis* theWrappedObject) const; + void visibleTickBounds(QCPAxis* theWrappedObject, int& lowIndex, int& highIndex) const; +}; + + + + + +class PythonQtShell_QCPAxisRect : public QCPAxisRect +{ +public: + PythonQtShell_QCPAxisRect(QCustomPlot* parentPlot, bool setupDefaultAxes = true):QCPAxisRect(parentPlot, setupDefaultAxes),_wrapper(NULL) { }; + + ~PythonQtShell_QCPAxisRect(); + +virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const; +virtual void childEvent(QChildEvent* arg__1); +virtual QRect clipRect() const; +virtual void customEvent(QEvent* arg__1); +virtual void deselectEvent(bool* selectionStateChanged); +virtual void draw(QCPPainter* painter); +virtual QList elements(bool recursive) const; +virtual bool event(QEvent* arg__1); +virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); +virtual QSize maximumSizeHint() const; +virtual QSize minimumSizeHint() const; +virtual void mouseDoubleClickEvent(QMouseEvent* event); +virtual void mouseMoveEvent(QMouseEvent* event); +virtual void mousePressEvent(QMouseEvent* event); +virtual void mouseReleaseEvent(QMouseEvent* event); +virtual void parentPlotInitialized(QCustomPlot* parentPlot); +virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); +virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; +virtual void timerEvent(QTimerEvent* arg__1); +virtual void wheelEvent(QWheelEvent* event); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPAxisRect : public QCPAxisRect +{ public: +inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPAxisRect::applyDefaultAntialiasingHint(painter); } +inline void promoted_draw(QCPPainter* painter) { QCPAxisRect::draw(painter); } +inline void promoted_drawBackground(QCPPainter* painter) { QCPAxisRect::drawBackground(painter); } +inline QList promoted_elements(bool recursive) const { return QCPAxisRect::elements(recursive); } +inline void promoted_mouseMoveEvent(QMouseEvent* event) { QCPAxisRect::mouseMoveEvent(event); } +inline void promoted_mousePressEvent(QMouseEvent* event) { QCPAxisRect::mousePressEvent(event); } +inline void promoted_mouseReleaseEvent(QMouseEvent* event) { QCPAxisRect::mouseReleaseEvent(event); } +inline void promoted_wheelEvent(QWheelEvent* event) { QCPAxisRect::wheelEvent(event); } +}; + +class PythonQtWrapper_QCPAxisRect : public QObject +{ Q_OBJECT +public: +public slots: +QCPAxisRect* new_QCPAxisRect(QCustomPlot* parentPlot, bool setupDefaultAxes = true); +void delete_QCPAxisRect(QCPAxisRect* obj) { delete obj; } + void applyDefaultAntialiasingHint(QCPAxisRect* theWrappedObject, QCPPainter* painter) const; + QList axes(QCPAxisRect* theWrappedObject) const; + QPixmap background(QCPAxisRect* theWrappedObject) const; + bool backgroundScaled(QCPAxisRect* theWrappedObject) const; + Qt::AspectRatioMode backgroundScaledMode(QCPAxisRect* theWrappedObject) const; + int bottom(QCPAxisRect* theWrappedObject) const; + QPoint bottomLeft(QCPAxisRect* theWrappedObject) const; + QPoint bottomRight(QCPAxisRect* theWrappedObject) const; + QPoint center(QCPAxisRect* theWrappedObject) const; + void draw(QCPAxisRect* theWrappedObject, QCPPainter* painter); + void drawBackground(QCPAxisRect* theWrappedObject, QCPPainter* painter); + QList elements(QCPAxisRect* theWrappedObject, bool recursive) const; + QList graphs(QCPAxisRect* theWrappedObject) const; + int height(QCPAxisRect* theWrappedObject) const; + QList items(QCPAxisRect* theWrappedObject) const; + int left(QCPAxisRect* theWrappedObject) const; + void mouseMoveEvent(QCPAxisRect* theWrappedObject, QMouseEvent* event); + void mousePressEvent(QCPAxisRect* theWrappedObject, QMouseEvent* event); + void mouseReleaseEvent(QCPAxisRect* theWrappedObject, QMouseEvent* event); + Qt::Orientations rangeDrag(QCPAxisRect* theWrappedObject) const; + QCPAxis* rangeDragAxis(QCPAxisRect* theWrappedObject, Qt::Orientation orientation); + Qt::Orientations rangeZoom(QCPAxisRect* theWrappedObject) const; + QCPAxis* rangeZoomAxis(QCPAxisRect* theWrappedObject, Qt::Orientation orientation); + double rangeZoomFactor(QCPAxisRect* theWrappedObject, Qt::Orientation orientation); + bool removeAxis(QCPAxisRect* theWrappedObject, QCPAxis* axis); + int right(QCPAxisRect* theWrappedObject) const; + void setBackground(QCPAxisRect* theWrappedObject, const QBrush& brush); + void setBackground(QCPAxisRect* theWrappedObject, const QPixmap& pm); + void setBackground(QCPAxisRect* theWrappedObject, const QPixmap& pm, bool scaled, Qt::AspectRatioMode mode = Qt::KeepAspectRatioByExpanding); + void setBackgroundScaled(QCPAxisRect* theWrappedObject, bool scaled); + void setBackgroundScaledMode(QCPAxisRect* theWrappedObject, Qt::AspectRatioMode mode); + void setRangeDrag(QCPAxisRect* theWrappedObject, Qt::Orientations orientations); + void setRangeDragAxes(QCPAxisRect* theWrappedObject, QCPAxis* horizontal, QCPAxis* vertical); + void setRangeZoom(QCPAxisRect* theWrappedObject, Qt::Orientations orientations); + void setRangeZoomAxes(QCPAxisRect* theWrappedObject, QCPAxis* horizontal, QCPAxis* vertical); + void setRangeZoomFactor(QCPAxisRect* theWrappedObject, double factor); + void setRangeZoomFactor(QCPAxisRect* theWrappedObject, double horizontalFactor, double verticalFactor); + void setupFullAxesBox(QCPAxisRect* theWrappedObject, bool connectRanges = false); + QSize size(QCPAxisRect* theWrappedObject) const; + int top(QCPAxisRect* theWrappedObject) const; + QPoint topLeft(QCPAxisRect* theWrappedObject) const; + QPoint topRight(QCPAxisRect* theWrappedObject) const; + void wheelEvent(QCPAxisRect* theWrappedObject, QWheelEvent* event); + int width(QCPAxisRect* theWrappedObject) const; +}; + + + + + +class PythonQtShell_QCPBars : public QCPBars +{ +public: + PythonQtShell_QCPBars(QCPAxis* keyAxis, QCPAxis* valueAxis):QCPBars(keyAxis, valueAxis),_wrapper(NULL) { }; + + ~PythonQtShell_QCPBars(); + +virtual void clearData(); +virtual void draw(QCPPainter* painter); +virtual void drawLegendIcon(QCPPainter* painter, const QRectF& rect) const; +virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPBars : public QCPBars +{ public: +inline void promoted_clearData() { QCPBars::clearData(); } +static inline void promoted_connectBars(QCPBars* lower, QCPBars* upper) { QCPBars::connectBars(lower, upper); } +inline void promoted_draw(QCPPainter* painter) { QCPBars::draw(painter); } +inline void promoted_drawLegendIcon(QCPPainter* painter, const QRectF& rect) const { QCPBars::drawLegendIcon(painter, rect); } +inline QPolygonF promoted_getBarPolygon(double key, double value) const { return QCPBars::getBarPolygon(key, value); } +inline void promoted_getPixelWidth(double key, double& lower, double& upper) const { QCPBars::getPixelWidth(key, lower, upper); } +inline double promoted_getStackedBaseValue(double key, bool positive) const { return QCPBars::getStackedBaseValue(key, positive); } +inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPBars::selectTest(pos, onlySelectable, details); } +}; + +class PythonQtWrapper_QCPBars : public QObject +{ Q_OBJECT +public: +public slots: +QCPBars* new_QCPBars(QCPAxis* keyAxis, QCPAxis* valueAxis); +void delete_QCPBars(QCPBars* obj) { delete obj; } + void addData(QCPBars* theWrappedObject, const QVector& keys, const QVector& values); + void addData(QCPBars* theWrappedObject, double key, double value); + QCPBars* barAbove(QCPBars* theWrappedObject) const; + QCPBars* barBelow(QCPBars* theWrappedObject) const; + double baseValue(QCPBars* theWrappedObject) const; + void clearData(QCPBars* theWrappedObject); + void static_QCPBars_connectBars(QCPBars* lower, QCPBars* upper); + void draw(QCPBars* theWrappedObject, QCPPainter* painter); + void drawLegendIcon(QCPBars* theWrappedObject, QCPPainter* painter, const QRectF& rect) const; + QPolygonF getBarPolygon(QCPBars* theWrappedObject, double key, double value) const; + void getPixelWidth(QCPBars* theWrappedObject, double key, double& lower, double& upper) const; + double getStackedBaseValue(QCPBars* theWrappedObject, double key, bool positive) const; + void moveAbove(QCPBars* theWrappedObject, QCPBars* bars); + void moveBelow(QCPBars* theWrappedObject, QCPBars* bars); + void removeData(QCPBars* theWrappedObject, double fromKey, double toKey); + void removeData(QCPBars* theWrappedObject, double key); + void removeDataAfter(QCPBars* theWrappedObject, double key); + void removeDataBefore(QCPBars* theWrappedObject, double key); + double selectTest(QCPBars* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + void setBaseValue(QCPBars* theWrappedObject, double baseValue); + void setData(QCPBars* theWrappedObject, const QVector& key, const QVector& value); + void setWidth(QCPBars* theWrappedObject, double width); + double width(QCPBars* theWrappedObject) const; +}; + + + + + +class PythonQtShell_QCPColorMap : public QCPColorMap +{ +public: + PythonQtShell_QCPColorMap(QCPAxis* keyAxis, QCPAxis* valueAxis):QCPColorMap(keyAxis, valueAxis),_wrapper(NULL) { }; + + ~PythonQtShell_QCPColorMap(); + +virtual void clearData(); +virtual void draw(QCPPainter* painter); +virtual void drawLegendIcon(QCPPainter* painter, const QRectF& rect) const; +virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; +virtual void updateMapImage(); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPColorMap : public QCPColorMap +{ public: +inline void promoted_clearData() { QCPColorMap::clearData(); } +inline void promoted_draw(QCPPainter* painter) { QCPColorMap::draw(painter); } +inline void promoted_drawLegendIcon(QCPPainter* painter, const QRectF& rect) const { QCPColorMap::drawLegendIcon(painter, rect); } +inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPColorMap::selectTest(pos, onlySelectable, details); } +inline void promoted_updateMapImage() { QCPColorMap::updateMapImage(); } +}; + +class PythonQtWrapper_QCPColorMap : public QObject +{ Q_OBJECT +public: +public slots: +QCPColorMap* new_QCPColorMap(QCPAxis* keyAxis, QCPAxis* valueAxis); +void delete_QCPColorMap(QCPColorMap* obj) { delete obj; } + void clearData(QCPColorMap* theWrappedObject); + QCPColorScale* colorScale(QCPColorMap* theWrappedObject) const; + void draw(QCPColorMap* theWrappedObject, QCPPainter* painter); + void drawLegendIcon(QCPColorMap* theWrappedObject, QCPPainter* painter, const QRectF& rect) const; + bool interpolate(QCPColorMap* theWrappedObject) const; + void rescaleDataRange(QCPColorMap* theWrappedObject, bool recalculateDataBounds = false); + double selectTest(QCPColorMap* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + void setColorScale(QCPColorMap* theWrappedObject, QCPColorScale* colorScale); + void setInterpolate(QCPColorMap* theWrappedObject, bool enabled); + void setTightBoundary(QCPColorMap* theWrappedObject, bool enabled); + bool tightBoundary(QCPColorMap* theWrappedObject) const; + void updateLegendIcon(QCPColorMap* theWrappedObject, Qt::TransformationMode transformMode = Qt::SmoothTransformation, const QSize& thumbSize = QSize(32, 18)); + void updateMapImage(QCPColorMap* theWrappedObject); +}; + + + + + +class PythonQtShell_QCPColorScale : public QCPColorScale +{ +public: + PythonQtShell_QCPColorScale(QCustomPlot* parentPlot):QCPColorScale(parentPlot),_wrapper(NULL) { }; + + ~PythonQtShell_QCPColorScale(); + +virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const; +virtual void childEvent(QChildEvent* arg__1); +virtual QRect clipRect() const; +virtual void customEvent(QEvent* arg__1); +virtual void deselectEvent(bool* selectionStateChanged); +virtual void draw(QCPPainter* painter); +virtual QList elements(bool recursive) const; +virtual bool event(QEvent* arg__1); +virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); +virtual QSize maximumSizeHint() const; +virtual QSize minimumSizeHint() const; +virtual void mouseDoubleClickEvent(QMouseEvent* event); +virtual void mouseMoveEvent(QMouseEvent* event); +virtual void mousePressEvent(QMouseEvent* event); +virtual void mouseReleaseEvent(QMouseEvent* event); +virtual void parentPlotInitialized(QCustomPlot* parentPlot); +virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); +virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; +virtual void timerEvent(QTimerEvent* arg__1); +virtual void wheelEvent(QWheelEvent* event); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPColorScale : public QCPColorScale +{ public: +inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPColorScale::applyDefaultAntialiasingHint(painter); } +inline void promoted_mouseMoveEvent(QMouseEvent* event) { QCPColorScale::mouseMoveEvent(event); } +inline void promoted_mousePressEvent(QMouseEvent* event) { QCPColorScale::mousePressEvent(event); } +inline void promoted_mouseReleaseEvent(QMouseEvent* event) { QCPColorScale::mouseReleaseEvent(event); } +inline void promoted_wheelEvent(QWheelEvent* event) { QCPColorScale::wheelEvent(event); } +}; + +class PythonQtWrapper_QCPColorScale : public QObject +{ Q_OBJECT +public: +public slots: +QCPColorScale* new_QCPColorScale(QCustomPlot* parentPlot); +void delete_QCPColorScale(QCPColorScale* obj) { delete obj; } + void applyDefaultAntialiasingHint(QCPColorScale* theWrappedObject, QCPPainter* painter) const; + QCPAxis* axis(QCPColorScale* theWrappedObject) const; + int barWidth(QCPColorScale* theWrappedObject) const; + QList colorMaps(QCPColorScale* theWrappedObject) const; + QString label(QCPColorScale* theWrappedObject) const; + void mouseMoveEvent(QCPColorScale* theWrappedObject, QMouseEvent* event); + void mousePressEvent(QCPColorScale* theWrappedObject, QMouseEvent* event); + void mouseReleaseEvent(QCPColorScale* theWrappedObject, QMouseEvent* event); + bool rangeDrag(QCPColorScale* theWrappedObject) const; + bool rangeZoom(QCPColorScale* theWrappedObject) const; + void rescaleDataRange(QCPColorScale* theWrappedObject, bool onlyVisibleMaps); + void setBarWidth(QCPColorScale* theWrappedObject, int width); + void setLabel(QCPColorScale* theWrappedObject, const QString& str); + void setRangeDrag(QCPColorScale* theWrappedObject, bool enabled); + void setRangeZoom(QCPColorScale* theWrappedObject, bool enabled); + void wheelEvent(QCPColorScale* theWrappedObject, QWheelEvent* event); +}; + + + + + +class PythonQtShell_QCPGraph : public QCPGraph +{ +public: + PythonQtShell_QCPGraph(QCPAxis* keyAxis, QCPAxis* valueAxis):QCPGraph(keyAxis, valueAxis),_wrapper(NULL) { }; + + ~PythonQtShell_QCPGraph(); + +virtual void clearData(); +virtual void draw(QCPPainter* painter); +virtual void drawFill(QCPPainter* painter, QVector* lineData) const; +virtual void drawImpulsePlot(QCPPainter* painter, QVector* lineData) const; +virtual void drawLegendIcon(QCPPainter* painter, const QRectF& rect) const; +virtual void drawLinePlot(QCPPainter* painter, QVector* lineData) const; +virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPGraph : public QCPGraph +{ public: +inline void promoted_addFillBasePoints(QVector* lineData) const { QCPGraph::addFillBasePoints(lineData); } +inline void promoted_clearData() { QCPGraph::clearData(); } +inline void promoted_draw(QCPPainter* painter) { QCPGraph::draw(painter); } +inline void promoted_drawFill(QCPPainter* painter, QVector* lineData) const { QCPGraph::drawFill(painter, lineData); } +inline void promoted_drawImpulsePlot(QCPPainter* painter, QVector* lineData) const { QCPGraph::drawImpulsePlot(painter, lineData); } +inline void promoted_drawLegendIcon(QCPPainter* painter, const QRectF& rect) const { QCPGraph::drawLegendIcon(painter, rect); } +inline void promoted_drawLinePlot(QCPPainter* painter, QVector* lineData) const { QCPGraph::drawLinePlot(painter, lineData); } +inline int promoted_findIndexAboveX(const QVector* data, double x) const { return QCPGraph::findIndexAboveX(data, x); } +inline int promoted_findIndexAboveY(const QVector* data, double y) const { return QCPGraph::findIndexAboveY(data, y); } +inline int promoted_findIndexBelowX(const QVector* data, double x) const { return QCPGraph::findIndexBelowX(data, x); } +inline int promoted_findIndexBelowY(const QVector* data, double y) const { return QCPGraph::findIndexBelowY(data, y); } +inline const QPolygonF promoted_getChannelFillPolygon(const QVector* lineData) const { return QCPGraph::getChannelFillPolygon(lineData); } +inline QPointF promoted_lowerFillBasePoint(double lowerKey) const { return QCPGraph::lowerFillBasePoint(lowerKey); } +inline double promoted_pointDistance(const QPointF& pixelPoint) const { return QCPGraph::pointDistance(pixelPoint); } +inline void promoted_removeFillBasePoints(QVector* lineData) const { QCPGraph::removeFillBasePoints(lineData); } +inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPGraph::selectTest(pos, onlySelectable, details); } +inline QPointF promoted_upperFillBasePoint(double upperKey) const { return QCPGraph::upperFillBasePoint(upperKey); } +}; + +class PythonQtWrapper_QCPGraph : public QObject +{ Q_OBJECT +public: +public slots: +QCPGraph* new_QCPGraph(QCPAxis* keyAxis, QCPAxis* valueAxis); +void delete_QCPGraph(QCPGraph* obj) { delete obj; } + bool adaptiveSampling(QCPGraph* theWrappedObject) const; + void addData(QCPGraph* theWrappedObject, const QVector& keys, const QVector& values); + void addData(QCPGraph* theWrappedObject, double key, double value); + void addFillBasePoints(QCPGraph* theWrappedObject, QVector* lineData) const; + QCPGraph* channelFillGraph(QCPGraph* theWrappedObject) const; + void clearData(QCPGraph* theWrappedObject); + void draw(QCPGraph* theWrappedObject, QCPPainter* painter); + void drawFill(QCPGraph* theWrappedObject, QCPPainter* painter, QVector* lineData) const; + void drawImpulsePlot(QCPGraph* theWrappedObject, QCPPainter* painter, QVector* lineData) const; + void drawLegendIcon(QCPGraph* theWrappedObject, QCPPainter* painter, const QRectF& rect) const; + void drawLinePlot(QCPGraph* theWrappedObject, QCPPainter* painter, QVector* lineData) const; + double errorBarSize(QCPGraph* theWrappedObject) const; + bool errorBarSkipSymbol(QCPGraph* theWrappedObject) const; + QPen errorPen(QCPGraph* theWrappedObject) const; + int findIndexAboveX(QCPGraph* theWrappedObject, const QVector* data, double x) const; + int findIndexAboveY(QCPGraph* theWrappedObject, const QVector* data, double y) const; + int findIndexBelowX(QCPGraph* theWrappedObject, const QVector* data, double x) const; + int findIndexBelowY(QCPGraph* theWrappedObject, const QVector* data, double y) const; + const QPolygonF getChannelFillPolygon(QCPGraph* theWrappedObject, const QVector* lineData) const; + QPointF lowerFillBasePoint(QCPGraph* theWrappedObject, double lowerKey) const; + double pointDistance(QCPGraph* theWrappedObject, const QPointF& pixelPoint) const; + void removeData(QCPGraph* theWrappedObject, double fromKey, double toKey); + void removeData(QCPGraph* theWrappedObject, double key); + void removeDataAfter(QCPGraph* theWrappedObject, double key); + void removeDataBefore(QCPGraph* theWrappedObject, double key); + void removeFillBasePoints(QCPGraph* theWrappedObject, QVector* lineData) const; + void rescaleAxes(QCPGraph* theWrappedObject, bool onlyEnlarge, bool includeErrorBars) const; + void rescaleKeyAxis(QCPGraph* theWrappedObject, bool onlyEnlarge, bool includeErrorBars) const; + void rescaleValueAxis(QCPGraph* theWrappedObject, bool onlyEnlarge, bool includeErrorBars) const; + double selectTest(QCPGraph* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + void setAdaptiveSampling(QCPGraph* theWrappedObject, bool enabled); + void setChannelFillGraph(QCPGraph* theWrappedObject, QCPGraph* targetGraph); + void setData(QCPGraph* theWrappedObject, const QVector& key, const QVector& value); + void setDataBothError(QCPGraph* theWrappedObject, const QVector& key, const QVector& value, const QVector& keyError, const QVector& valueError); + void setDataBothError(QCPGraph* theWrappedObject, const QVector& key, const QVector& value, const QVector& keyErrorMinus, const QVector& keyErrorPlus, const QVector& valueErrorMinus, const QVector& valueErrorPlus); + void setDataKeyError(QCPGraph* theWrappedObject, const QVector& key, const QVector& value, const QVector& keyError); + void setDataKeyError(QCPGraph* theWrappedObject, const QVector& key, const QVector& value, const QVector& keyErrorMinus, const QVector& keyErrorPlus); + void setDataValueError(QCPGraph* theWrappedObject, const QVector& key, const QVector& value, const QVector& valueError); + void setDataValueError(QCPGraph* theWrappedObject, const QVector& key, const QVector& value, const QVector& valueErrorMinus, const QVector& valueErrorPlus); + void setErrorBarSize(QCPGraph* theWrappedObject, double size); + void setErrorBarSkipSymbol(QCPGraph* theWrappedObject, bool enabled); + void setErrorPen(QCPGraph* theWrappedObject, const QPen& pen); + void setUseFastVectors(QCPGraph* theWrappedObject, bool useFastVectors); + QPointF upperFillBasePoint(QCPGraph* theWrappedObject, double upperKey) const; + bool useFastVectors(QCPGraph* theWrappedObject) const; +}; + + + + + +class PythonQtShell_QCPItemPosition : public QCPItemPosition +{ +public: + PythonQtShell_QCPItemPosition(QCustomPlot* parentPlot, QCPAbstractItem* parentItem, const QString name):QCPItemPosition(parentPlot, parentItem, name),_wrapper(NULL) { }; + + ~PythonQtShell_QCPItemPosition(); + +virtual QPointF pixelPoint() const; +virtual QCPItemPosition* toQCPItemPosition(); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPItemPosition : public QCPItemPosition +{ public: +inline QPointF promoted_pixelPoint() const { return QCPItemPosition::pixelPoint(); } +inline QCPItemPosition* promoted_toQCPItemPosition() { return QCPItemPosition::toQCPItemPosition(); } +}; + +class PythonQtWrapper_QCPItemPosition : public QObject +{ Q_OBJECT +public: +public slots: +QCPItemPosition* new_QCPItemPosition(QCustomPlot* parentPlot, QCPAbstractItem* parentItem, const QString name); +void delete_QCPItemPosition(QCPItemPosition* obj) { delete obj; } + QCPAxisRect* axisRect(QCPItemPosition* theWrappedObject) const; + QPointF coords(QCPItemPosition* theWrappedObject) const; + double key(QCPItemPosition* theWrappedObject) const; + QCPAxis* keyAxis(QCPItemPosition* theWrappedObject) const; + QPointF pixelPoint(QCPItemPosition* theWrappedObject) const; + void setAxes(QCPItemPosition* theWrappedObject, QCPAxis* keyAxis, QCPAxis* valueAxis); + void setAxisRect(QCPItemPosition* theWrappedObject, QCPAxisRect* axisRect); + void setCoords(QCPItemPosition* theWrappedObject, const QPointF& coords); + void setCoords(QCPItemPosition* theWrappedObject, double key, double value); + void setPixelPoint(QCPItemPosition* theWrappedObject, const QPointF& pixelPoint); + QCPItemPosition* toQCPItemPosition(QCPItemPosition* theWrappedObject); + double value(QCPItemPosition* theWrappedObject) const; + QCPAxis* valueAxis(QCPItemPosition* theWrappedObject) const; +}; + + + + + +class PythonQtShell_QCPLayer : public QCPLayer +{ +public: + PythonQtShell_QCPLayer(QCustomPlot* parentPlot, const QString& layerName):QCPLayer(parentPlot, layerName),_wrapper(NULL) { }; + + ~PythonQtShell_QCPLayer(); + +virtual void childEvent(QChildEvent* arg__1); +virtual void customEvent(QEvent* arg__1); +virtual bool event(QEvent* arg__1); +virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); +virtual void timerEvent(QTimerEvent* arg__1); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPLayer : public QCPLayer +{ public: +inline void promoted_addChild(QCPLayerable* layerable, bool prepend) { QCPLayer::addChild(layerable, prepend); } +inline void promoted_removeChild(QCPLayerable* layerable) { QCPLayer::removeChild(layerable); } +}; + +class PythonQtWrapper_QCPLayer : public QObject +{ Q_OBJECT +public: +public slots: +QCPLayer* new_QCPLayer(QCustomPlot* parentPlot, const QString& layerName); +void delete_QCPLayer(QCPLayer* obj) { delete obj; } + void addChild(QCPLayer* theWrappedObject, QCPLayerable* layerable, bool prepend); + QList children(QCPLayer* theWrappedObject) const; + int index(QCPLayer* theWrappedObject) const; + QString name(QCPLayer* theWrappedObject) const; + QCustomPlot* parentPlot(QCPLayer* theWrappedObject) const; + void removeChild(QCPLayer* theWrappedObject, QCPLayerable* layerable); + void setVisible(QCPLayer* theWrappedObject, bool visible); + bool visible(QCPLayer* theWrappedObject) const; +}; + + + + + +class PythonQtShell_QCPLayerable : public QCPLayerable +{ +public: + PythonQtShell_QCPLayerable(QCustomPlot* plot, QString targetLayer = QString(), QCPLayerable* parentLayerable = 0):QCPLayerable(plot, targetLayer, parentLayerable),_wrapper(NULL) { }; + + ~PythonQtShell_QCPLayerable(); + +virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const; +virtual void childEvent(QChildEvent* arg__1); +virtual QRect clipRect() const; +virtual void customEvent(QEvent* arg__1); +virtual void deselectEvent(bool* selectionStateChanged); +virtual void draw(QCPPainter* painter); +virtual bool event(QEvent* arg__1); +virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); +virtual void parentPlotInitialized(QCustomPlot* parentPlot); +virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); +virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; +virtual void timerEvent(QTimerEvent* arg__1); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPLayerable : public QCPLayerable +{ public: +inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { applyDefaultAntialiasingHint(painter); } +inline QRect promoted_clipRect() const { return QCPLayerable::clipRect(); } +inline void promoted_deselectEvent(bool* selectionStateChanged) { QCPLayerable::deselectEvent(selectionStateChanged); } +inline void promoted_draw(QCPPainter* painter) { draw(painter); } +inline void promoted_initializeParentPlot(QCustomPlot* parentPlot) { QCPLayerable::initializeParentPlot(parentPlot); } +inline bool promoted_moveToLayer(QCPLayer* layer, bool prepend) { return QCPLayerable::moveToLayer(layer, prepend); } +inline void promoted_parentPlotInitialized(QCustomPlot* parentPlot) { QCPLayerable::parentPlotInitialized(parentPlot); } +inline void promoted_selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) { QCPLayerable::selectEvent(event, additive, details, selectionStateChanged); } +inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPLayerable::selectTest(pos, onlySelectable, details); } +inline void promoted_setParentLayerable(QCPLayerable* parentLayerable) { QCPLayerable::setParentLayerable(parentLayerable); } +}; + +class PythonQtWrapper_QCPLayerable : public QObject +{ Q_OBJECT +public: +public slots: +QCPLayerable* new_QCPLayerable(QCustomPlot* plot, QString targetLayer = QString(), QCPLayerable* parentLayerable = 0); +void delete_QCPLayerable(QCPLayerable* obj) { delete obj; } + bool antialiased(QCPLayerable* theWrappedObject) const; + void applyDefaultAntialiasingHint(QCPLayerable* theWrappedObject, QCPPainter* painter) const; + QRect clipRect(QCPLayerable* theWrappedObject) const; + void deselectEvent(QCPLayerable* theWrappedObject, bool* selectionStateChanged); + void draw(QCPLayerable* theWrappedObject, QCPPainter* painter); + void initializeParentPlot(QCPLayerable* theWrappedObject, QCustomPlot* parentPlot); + QCPLayer* layer(QCPLayerable* theWrappedObject) const; + bool moveToLayer(QCPLayerable* theWrappedObject, QCPLayer* layer, bool prepend); + QCPLayerable* parentLayerable(QCPLayerable* theWrappedObject) const; + QCustomPlot* parentPlot(QCPLayerable* theWrappedObject) const; + void parentPlotInitialized(QCPLayerable* theWrappedObject, QCustomPlot* parentPlot); + bool realVisibility(QCPLayerable* theWrappedObject) const; + void selectEvent(QCPLayerable* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); + double selectTest(QCPLayerable* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + void setAntialiased(QCPLayerable* theWrappedObject, bool enabled); + bool setLayer(QCPLayerable* theWrappedObject, QCPLayer* layer); + bool setLayer(QCPLayerable* theWrappedObject, const QString& layerName); + void setParentLayerable(QCPLayerable* theWrappedObject, QCPLayerable* parentLayerable); + void setVisible(QCPLayerable* theWrappedObject, bool on); + bool visible(QCPLayerable* theWrappedObject) const; +}; + + + + + +class PythonQtShell_QCPLayout : public QCPLayout +{ +public: + PythonQtShell_QCPLayout():QCPLayout(),_wrapper(NULL) { }; + + ~PythonQtShell_QCPLayout(); + +virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const; +virtual void childEvent(QChildEvent* arg__1); +virtual QRect clipRect() const; +virtual void customEvent(QEvent* arg__1); +virtual void deselectEvent(bool* selectionStateChanged); +virtual void draw(QCPPainter* painter); +virtual QCPLayoutElement* elementAt(int index) const; +virtual int elementCount() const; +virtual QList elements(bool recursive) const; +virtual bool event(QEvent* arg__1); +virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); +virtual QSize maximumSizeHint() const; +virtual QSize minimumSizeHint() const; +virtual void mouseDoubleClickEvent(QMouseEvent* event); +virtual void mouseMoveEvent(QMouseEvent* event); +virtual void mousePressEvent(QMouseEvent* event); +virtual void mouseReleaseEvent(QMouseEvent* event); +virtual void parentPlotInitialized(QCustomPlot* parentPlot); +virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); +virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; +virtual void simplify(); +virtual bool take(QCPLayoutElement* element); +virtual QCPLayoutElement* takeAt(int index); +virtual void timerEvent(QTimerEvent* arg__1); +virtual void updateLayout(); +virtual void wheelEvent(QWheelEvent* event); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPLayout : public QCPLayout +{ public: +inline void promoted_adoptElement(QCPLayoutElement* el) { QCPLayout::adoptElement(el); } +inline QCPLayoutElement* promoted_elementAt(int index) const { return elementAt(index); } +inline int promoted_elementCount() const { return elementCount(); } +inline QList promoted_elements(bool recursive) const { return QCPLayout::elements(recursive); } +inline QVector promoted_getSectionSizes(QVector maxSizes, QVector minSizes, QVector stretchFactors, int totalSize) const { return QCPLayout::getSectionSizes(maxSizes, minSizes, stretchFactors, totalSize); } +inline void promoted_releaseElement(QCPLayoutElement* el) { QCPLayout::releaseElement(el); } +inline void promoted_simplify() { QCPLayout::simplify(); } +inline void promoted_sizeConstraintsChanged() const { QCPLayout::sizeConstraintsChanged(); } +inline bool promoted_take(QCPLayoutElement* element) { return take(element); } +inline QCPLayoutElement* promoted_takeAt(int index) { return takeAt(index); } +inline void promoted_updateLayout() { QCPLayout::updateLayout(); } +}; + +class PythonQtWrapper_QCPLayout : public QObject +{ Q_OBJECT +public: +public slots: +QCPLayout* new_QCPLayout(); +void delete_QCPLayout(QCPLayout* obj) { delete obj; } + void adoptElement(QCPLayout* theWrappedObject, QCPLayoutElement* el); + void clear(QCPLayout* theWrappedObject); + QCPLayoutElement* elementAt(QCPLayout* theWrappedObject, int index) const; + int elementCount(QCPLayout* theWrappedObject) const; + QList elements(QCPLayout* theWrappedObject, bool recursive) const; + QVector getSectionSizes(QCPLayout* theWrappedObject, QVector maxSizes, QVector minSizes, QVector stretchFactors, int totalSize) const; + void releaseElement(QCPLayout* theWrappedObject, QCPLayoutElement* el); + bool remove(QCPLayout* theWrappedObject, QCPLayoutElement* element); + bool removeAt(QCPLayout* theWrappedObject, int index); + void simplify(QCPLayout* theWrappedObject); + void sizeConstraintsChanged(QCPLayout* theWrappedObject) const; + bool take(QCPLayout* theWrappedObject, QCPLayoutElement* element); + QCPLayoutElement* takeAt(QCPLayout* theWrappedObject, int index); + void updateLayout(QCPLayout* theWrappedObject); +}; + + + + + +class PythonQtShell_QCPLayoutElement : public QCPLayoutElement +{ +public: + PythonQtShell_QCPLayoutElement(QCustomPlot* parentPlot = 0):QCPLayoutElement(parentPlot),_wrapper(NULL) { }; + + ~PythonQtShell_QCPLayoutElement(); + +virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const; +virtual void childEvent(QChildEvent* arg__1); +virtual QRect clipRect() const; +virtual void customEvent(QEvent* arg__1); +virtual void deselectEvent(bool* selectionStateChanged); +virtual void draw(QCPPainter* painter); +virtual QList elements(bool recursive) const; +virtual bool event(QEvent* arg__1); +virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); +virtual QSize maximumSizeHint() const; +virtual QSize minimumSizeHint() const; +virtual void mouseDoubleClickEvent(QMouseEvent* event); +virtual void mouseMoveEvent(QMouseEvent* event); +virtual void mousePressEvent(QMouseEvent* event); +virtual void mouseReleaseEvent(QMouseEvent* event); +virtual void parentPlotInitialized(QCustomPlot* parentPlot); +virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); +virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; +virtual void timerEvent(QTimerEvent* arg__1); +virtual void wheelEvent(QWheelEvent* event); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPLayoutElement : public QCPLayoutElement +{ public: +inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPLayoutElement::applyDefaultAntialiasingHint(painter); } +inline void promoted_draw(QCPPainter* painter) { QCPLayoutElement::draw(painter); } +inline QList promoted_elements(bool recursive) const { return QCPLayoutElement::elements(recursive); } +inline QSize promoted_maximumSizeHint() const { return QCPLayoutElement::maximumSizeHint(); } +inline QSize promoted_minimumSizeHint() const { return QCPLayoutElement::minimumSizeHint(); } +inline void promoted_mouseDoubleClickEvent(QMouseEvent* event) { QCPLayoutElement::mouseDoubleClickEvent(event); } +inline void promoted_mouseMoveEvent(QMouseEvent* event) { QCPLayoutElement::mouseMoveEvent(event); } +inline void promoted_mousePressEvent(QMouseEvent* event) { QCPLayoutElement::mousePressEvent(event); } +inline void promoted_mouseReleaseEvent(QMouseEvent* event) { QCPLayoutElement::mouseReleaseEvent(event); } +inline void promoted_parentPlotInitialized(QCustomPlot* parentPlot) { QCPLayoutElement::parentPlotInitialized(parentPlot); } +inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPLayoutElement::selectTest(pos, onlySelectable, details); } +inline void promoted_wheelEvent(QWheelEvent* event) { QCPLayoutElement::wheelEvent(event); } +}; + +class PythonQtWrapper_QCPLayoutElement : public QObject +{ Q_OBJECT +public: +public slots: +QCPLayoutElement* new_QCPLayoutElement(QCustomPlot* parentPlot = 0); +void delete_QCPLayoutElement(QCPLayoutElement* obj) { delete obj; } + void applyDefaultAntialiasingHint(QCPLayoutElement* theWrappedObject, QCPPainter* painter) const; + void draw(QCPLayoutElement* theWrappedObject, QCPPainter* painter); + QList elements(QCPLayoutElement* theWrappedObject, bool recursive) const; + QCPLayout* layout(QCPLayoutElement* theWrappedObject) const; + QMargins margins(QCPLayoutElement* theWrappedObject) const; + QSize maximumSize(QCPLayoutElement* theWrappedObject) const; + QSize maximumSizeHint(QCPLayoutElement* theWrappedObject) const; + QMargins minimumMargins(QCPLayoutElement* theWrappedObject) const; + QSize minimumSize(QCPLayoutElement* theWrappedObject) const; + QSize minimumSizeHint(QCPLayoutElement* theWrappedObject) const; + void mouseDoubleClickEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event); + void mouseMoveEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event); + void mousePressEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event); + void mouseReleaseEvent(QCPLayoutElement* theWrappedObject, QMouseEvent* event); + QRect outerRect(QCPLayoutElement* theWrappedObject) const; + void parentPlotInitialized(QCPLayoutElement* theWrappedObject, QCustomPlot* parentPlot); + QRect rect(QCPLayoutElement* theWrappedObject) const; + double selectTest(QCPLayoutElement* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + void setMargins(QCPLayoutElement* theWrappedObject, const QMargins& margins); + void setMaximumSize(QCPLayoutElement* theWrappedObject, const QSize& size); + void setMaximumSize(QCPLayoutElement* theWrappedObject, int width, int height); + void setMinimumMargins(QCPLayoutElement* theWrappedObject, const QMargins& margins); + void setMinimumSize(QCPLayoutElement* theWrappedObject, const QSize& size); + void setMinimumSize(QCPLayoutElement* theWrappedObject, int width, int height); + void setOuterRect(QCPLayoutElement* theWrappedObject, const QRect& rect); + void wheelEvent(QCPLayoutElement* theWrappedObject, QWheelEvent* event); +}; + + + + + +class PythonQtShell_QCPLegend : public QCPLegend +{ +public: + PythonQtShell_QCPLegend():QCPLegend(),_wrapper(NULL) { }; + + ~PythonQtShell_QCPLegend(); + +virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const; +virtual void deselectEvent(bool* selectionStateChanged); +virtual void draw(QCPPainter* painter); +virtual void parentPlotInitialized(QCustomPlot* parentPlot); +virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); +virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPLegend : public QCPLegend +{ public: +inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPLegend::applyDefaultAntialiasingHint(painter); } +inline void promoted_deselectEvent(bool* selectionStateChanged) { QCPLegend::deselectEvent(selectionStateChanged); } +inline void promoted_draw(QCPPainter* painter) { QCPLegend::draw(painter); } +inline QPen promoted_getBorderPen() const { return QCPLegend::getBorderPen(); } +inline QBrush promoted_getBrush() const { return QCPLegend::getBrush(); } +inline void promoted_parentPlotInitialized(QCustomPlot* parentPlot) { QCPLegend::parentPlotInitialized(parentPlot); } +inline void promoted_selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) { QCPLegend::selectEvent(event, additive, details, selectionStateChanged); } +inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPLegend::selectTest(pos, onlySelectable, details); } +}; + +class PythonQtWrapper_QCPLegend : public QObject +{ Q_OBJECT +public: +public slots: +QCPLegend* new_QCPLegend(); +void delete_QCPLegend(QCPLegend* obj) { delete obj; } + bool addItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem* item); + void applyDefaultAntialiasingHint(QCPLegend* theWrappedObject, QCPPainter* painter) const; + QPen borderPen(QCPLegend* theWrappedObject) const; + QBrush brush(QCPLegend* theWrappedObject) const; + void clearItems(QCPLegend* theWrappedObject); + void deselectEvent(QCPLegend* theWrappedObject, bool* selectionStateChanged); + void draw(QCPLegend* theWrappedObject, QCPPainter* painter); + QFont font(QCPLegend* theWrappedObject) const; + QPen getBorderPen(QCPLegend* theWrappedObject) const; + QBrush getBrush(QCPLegend* theWrappedObject) const; + bool hasItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem* item) const; + QPen iconBorderPen(QCPLegend* theWrappedObject) const; + QSize iconSize(QCPLegend* theWrappedObject) const; + int iconTextPadding(QCPLegend* theWrappedObject) const; + QCPAbstractLegendItem* item(QCPLegend* theWrappedObject, int index) const; + int itemCount(QCPLegend* theWrappedObject) const; + void parentPlotInitialized(QCPLegend* theWrappedObject, QCustomPlot* parentPlot); + bool removeItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem* item); + bool removeItem(QCPLegend* theWrappedObject, int index); + void selectEvent(QCPLegend* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); + double selectTest(QCPLegend* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + QPen selectedBorderPen(QCPLegend* theWrappedObject) const; + QBrush selectedBrush(QCPLegend* theWrappedObject) const; + QFont selectedFont(QCPLegend* theWrappedObject) const; + QPen selectedIconBorderPen(QCPLegend* theWrappedObject) const; + QList selectedItems(QCPLegend* theWrappedObject) const; + QColor selectedTextColor(QCPLegend* theWrappedObject) const; + void setBorderPen(QCPLegend* theWrappedObject, const QPen& pen); + void setBrush(QCPLegend* theWrappedObject, const QBrush& brush); + void setFont(QCPLegend* theWrappedObject, const QFont& font); + void setIconBorderPen(QCPLegend* theWrappedObject, const QPen& pen); + void setIconSize(QCPLegend* theWrappedObject, const QSize& size); + void setIconSize(QCPLegend* theWrappedObject, int width, int height); + void setIconTextPadding(QCPLegend* theWrappedObject, int padding); + void setSelectedBorderPen(QCPLegend* theWrappedObject, const QPen& pen); + void setSelectedBrush(QCPLegend* theWrappedObject, const QBrush& brush); + void setSelectedFont(QCPLegend* theWrappedObject, const QFont& font); + void setSelectedIconBorderPen(QCPLegend* theWrappedObject, const QPen& pen); + void setSelectedTextColor(QCPLegend* theWrappedObject, const QColor& color); + void setTextColor(QCPLegend* theWrappedObject, const QColor& color); + QColor textColor(QCPLegend* theWrappedObject) const; +}; + + + + + +class PythonQtShell_QCPPainter : public QCPPainter +{ +public: + PythonQtShell_QCPPainter():QCPPainter(),_wrapper(NULL) { }; + PythonQtShell_QCPPainter(QPaintDevice* device):QCPPainter(device),_wrapper(NULL) { }; + + ~PythonQtShell_QCPPainter(); + + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtWrapper_QCPPainter : public QObject +{ Q_OBJECT +public: +public slots: +QCPPainter* new_QCPPainter(); +QCPPainter* new_QCPPainter(QPaintDevice* device); +void delete_QCPPainter(QCPPainter* obj) { delete obj; } + bool antialiasing(QCPPainter* theWrappedObject) const; + bool begin(QCPPainter* theWrappedObject, QPaintDevice* device); + void drawLine(QCPPainter* theWrappedObject, const QLineF& line); + void drawLine(QCPPainter* theWrappedObject, const QPointF& p1, const QPointF& p2); + void makeNonCosmetic(QCPPainter* theWrappedObject); + void restore(QCPPainter* theWrappedObject); + void save(QCPPainter* theWrappedObject); + void setAntialiasing(QCPPainter* theWrappedObject, bool enabled); + void setPen(QCPPainter* theWrappedObject, Qt::PenStyle penStyle); + void setPen(QCPPainter* theWrappedObject, const QColor& color); + void setPen(QCPPainter* theWrappedObject, const QPen& pen); +}; + + + + + +class PythonQtShell_QCPPlotTitle : public QCPPlotTitle +{ +public: + PythonQtShell_QCPPlotTitle(QCustomPlot* parentPlot):QCPPlotTitle(parentPlot),_wrapper(NULL) { }; + PythonQtShell_QCPPlotTitle(QCustomPlot* parentPlot, const QString& text):QCPPlotTitle(parentPlot, text),_wrapper(NULL) { }; + + ~PythonQtShell_QCPPlotTitle(); + +virtual void applyDefaultAntialiasingHint(QCPPainter* painter) const; +virtual void childEvent(QChildEvent* arg__1); +virtual QRect clipRect() const; +virtual void customEvent(QEvent* arg__1); +virtual void deselectEvent(bool* selectionStateChanged); +virtual void draw(QCPPainter* painter); +virtual QList elements(bool recursive) const; +virtual bool event(QEvent* arg__1); +virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); +virtual QSize maximumSizeHint() const; +virtual QSize minimumSizeHint() const; +virtual void mouseDoubleClickEvent(QMouseEvent* event); +virtual void mouseMoveEvent(QMouseEvent* event); +virtual void mousePressEvent(QMouseEvent* event); +virtual void mouseReleaseEvent(QMouseEvent* event); +virtual void parentPlotInitialized(QCustomPlot* parentPlot); +virtual void selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); +virtual double selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; +virtual void timerEvent(QTimerEvent* arg__1); +virtual void wheelEvent(QWheelEvent* event); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCPPlotTitle : public QCPPlotTitle +{ public: +inline void promoted_applyDefaultAntialiasingHint(QCPPainter* painter) const { QCPPlotTitle::applyDefaultAntialiasingHint(painter); } +inline void promoted_deselectEvent(bool* selectionStateChanged) { QCPPlotTitle::deselectEvent(selectionStateChanged); } +inline void promoted_draw(QCPPainter* painter) { QCPPlotTitle::draw(painter); } +inline QFont promoted_mainFont() const { return QCPPlotTitle::mainFont(); } +inline QColor promoted_mainTextColor() const { return QCPPlotTitle::mainTextColor(); } +inline QSize promoted_maximumSizeHint() const { return QCPPlotTitle::maximumSizeHint(); } +inline QSize promoted_minimumSizeHint() const { return QCPPlotTitle::minimumSizeHint(); } +inline void promoted_selectEvent(QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged) { QCPPlotTitle::selectEvent(event, additive, details, selectionStateChanged); } +inline double promoted_selectTest(const QPointF& pos, bool onlySelectable, QVariant* details = 0) const { return QCPPlotTitle::selectTest(pos, onlySelectable, details); } +}; + +class PythonQtWrapper_QCPPlotTitle : public QObject +{ Q_OBJECT +public: +public slots: +QCPPlotTitle* new_QCPPlotTitle(QCustomPlot* parentPlot); +QCPPlotTitle* new_QCPPlotTitle(QCustomPlot* parentPlot, const QString& text); +void delete_QCPPlotTitle(QCPPlotTitle* obj) { delete obj; } + void applyDefaultAntialiasingHint(QCPPlotTitle* theWrappedObject, QCPPainter* painter) const; + void deselectEvent(QCPPlotTitle* theWrappedObject, bool* selectionStateChanged); + void draw(QCPPlotTitle* theWrappedObject, QCPPainter* painter); + QFont font(QCPPlotTitle* theWrappedObject) const; + QFont mainFont(QCPPlotTitle* theWrappedObject) const; + QColor mainTextColor(QCPPlotTitle* theWrappedObject) const; + QSize maximumSizeHint(QCPPlotTitle* theWrappedObject) const; + QSize minimumSizeHint(QCPPlotTitle* theWrappedObject) const; + void selectEvent(QCPPlotTitle* theWrappedObject, QMouseEvent* event, bool additive, const QVariant& details, bool* selectionStateChanged); + double selectTest(QCPPlotTitle* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* details = 0) const; + bool selectable(QCPPlotTitle* theWrappedObject) const; + bool selected(QCPPlotTitle* theWrappedObject) const; + QFont selectedFont(QCPPlotTitle* theWrappedObject) const; + QColor selectedTextColor(QCPPlotTitle* theWrappedObject) const; + void setFont(QCPPlotTitle* theWrappedObject, const QFont& font); + void setSelectable(QCPPlotTitle* theWrappedObject, bool selectable); + void setSelected(QCPPlotTitle* theWrappedObject, bool selected); + void setSelectedFont(QCPPlotTitle* theWrappedObject, const QFont& font); + void setSelectedTextColor(QCPPlotTitle* theWrappedObject, const QColor& color); + void setText(QCPPlotTitle* theWrappedObject, const QString& text); + void setTextColor(QCPPlotTitle* theWrappedObject, const QColor& color); + QString text(QCPPlotTitle* theWrappedObject) const; + QColor textColor(QCPPlotTitle* theWrappedObject) const; +}; + + + + + +class PythonQtShell_QCustomPlot : public QCustomPlot +{ +public: + PythonQtShell_QCustomPlot(QWidget* parent = 0):QCustomPlot(parent),_wrapper(NULL) { }; + + ~PythonQtShell_QCustomPlot(); + +virtual void actionEvent(QActionEvent* arg__1); +virtual void axisRemoved(QCPAxis* axis); +virtual void changeEvent(QEvent* arg__1); +virtual void childEvent(QChildEvent* arg__1); +virtual void closeEvent(QCloseEvent* arg__1); +virtual void contextMenuEvent(QContextMenuEvent* arg__1); +virtual void customEvent(QEvent* arg__1); +virtual int devType() const; +virtual void dragEnterEvent(QDragEnterEvent* arg__1); +virtual void dragLeaveEvent(QDragLeaveEvent* arg__1); +virtual void dragMoveEvent(QDragMoveEvent* arg__1); +virtual void draw(QCPPainter* painter); +virtual void dropEvent(QDropEvent* arg__1); +virtual void enterEvent(QEvent* arg__1); +virtual bool event(QEvent* arg__1); +virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); +virtual void focusInEvent(QFocusEvent* arg__1); +virtual bool focusNextPrevChild(bool next); +virtual void focusOutEvent(QFocusEvent* arg__1); +virtual bool hasHeightForWidth() const; +virtual int heightForWidth(int arg__1) const; +virtual void hideEvent(QHideEvent* arg__1); +virtual void initPainter(QPainter* painter) const; +virtual void inputMethodEvent(QInputMethodEvent* arg__1); +virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const; +virtual void keyPressEvent(QKeyEvent* arg__1); +virtual void keyReleaseEvent(QKeyEvent* arg__1); +virtual void leaveEvent(QEvent* arg__1); +virtual void legendRemoved(QCPLegend* legend); +virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const; +virtual QSize minimumSizeHint() const; +virtual void mouseDoubleClickEvent(QMouseEvent* event); +virtual void mouseMoveEvent(QMouseEvent* event); +virtual void mousePressEvent(QMouseEvent* event); +virtual void mouseReleaseEvent(QMouseEvent* event); +virtual void moveEvent(QMoveEvent* arg__1); +virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result); +virtual QPaintEngine* paintEngine() const; +virtual void paintEvent(QPaintEvent* event); +virtual QPaintDevice* redirected(QPoint* offset) const; +virtual void resizeEvent(QResizeEvent* event); +virtual QPainter* sharedPainter() const; +virtual void showEvent(QShowEvent* arg__1); +virtual QSize sizeHint() const; +virtual void tabletEvent(QTabletEvent* arg__1); +virtual void timerEvent(QTimerEvent* arg__1); +virtual void wheelEvent(QWheelEvent* event); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QCustomPlot : public QCustomPlot +{ public: +inline void promoted_axisRemoved(QCPAxis* axis) { QCustomPlot::axisRemoved(axis); } +inline void promoted_draw(QCPPainter* painter) { QCustomPlot::draw(painter); } +inline void promoted_drawBackground(QCPPainter* painter) { QCustomPlot::drawBackground(painter); } +inline QCPLayerable* promoted_layerableAt(const QPointF& pos, bool onlySelectable, QVariant* selectionDetails = 0) const { return QCustomPlot::layerableAt(pos, onlySelectable, selectionDetails); } +inline void promoted_legendRemoved(QCPLegend* legend) { QCustomPlot::legendRemoved(legend); } +inline QSize promoted_minimumSizeHint() const { return QCustomPlot::minimumSizeHint(); } +inline void promoted_mouseDoubleClickEvent(QMouseEvent* event) { QCustomPlot::mouseDoubleClickEvent(event); } +inline void promoted_mouseMoveEvent(QMouseEvent* event) { QCustomPlot::mouseMoveEvent(event); } +inline void promoted_mousePressEvent(QMouseEvent* event) { QCustomPlot::mousePressEvent(event); } +inline void promoted_mouseReleaseEvent(QMouseEvent* event) { QCustomPlot::mouseReleaseEvent(event); } +inline void promoted_paintEvent(QPaintEvent* event) { QCustomPlot::paintEvent(event); } +inline void promoted_resizeEvent(QResizeEvent* event) { QCustomPlot::resizeEvent(event); } +inline QSize promoted_sizeHint() const { return QCustomPlot::sizeHint(); } +inline void promoted_updateLayerIndices() const { QCustomPlot::updateLayerIndices(); } +inline void promoted_wheelEvent(QWheelEvent* event) { QCustomPlot::wheelEvent(event); } +}; + +class PythonQtWrapper_QCustomPlot : public QObject +{ Q_OBJECT +public: +public slots: +QCustomPlot* new_QCustomPlot(QWidget* parent = 0); +void delete_QCustomPlot(QCustomPlot* obj) { delete obj; } + QCPGraph* addGraph(QCustomPlot* theWrappedObject, QCPAxis* keyAxis = 0, QCPAxis* valueAxis = 0); + bool addItem(QCustomPlot* theWrappedObject, QCPAbstractItem* item); + bool autoAddPlottableToLegend(QCustomPlot* theWrappedObject) const; + QCPAxisRect* axisRect(QCustomPlot* theWrappedObject, int index = 0) const; + int axisRectCount(QCustomPlot* theWrappedObject) const; + QList axisRects(QCustomPlot* theWrappedObject) const; + void axisRemoved(QCustomPlot* theWrappedObject, QCPAxis* axis); + QPixmap background(QCustomPlot* theWrappedObject) const; + bool backgroundScaled(QCustomPlot* theWrappedObject) const; + Qt::AspectRatioMode backgroundScaledMode(QCustomPlot* theWrappedObject) const; + int clearGraphs(QCustomPlot* theWrappedObject); + int clearItems(QCustomPlot* theWrappedObject); + int clearPlottables(QCustomPlot* theWrappedObject); + QCPLayer* currentLayer(QCustomPlot* theWrappedObject) const; + void deselectAll(QCustomPlot* theWrappedObject); + void draw(QCustomPlot* theWrappedObject, QCPPainter* painter); + void drawBackground(QCustomPlot* theWrappedObject, QCPPainter* painter); + QCPGraph* graph(QCustomPlot* theWrappedObject) const; + QCPGraph* graph(QCustomPlot* theWrappedObject, int index) const; + int graphCount(QCustomPlot* theWrappedObject) const; + bool hasItem(QCustomPlot* theWrappedObject, QCPAbstractItem* item) const; + QCPAbstractItem* item(QCustomPlot* theWrappedObject) const; + QCPAbstractItem* item(QCustomPlot* theWrappedObject, int index) const; + QCPAbstractItem* itemAt(QCustomPlot* theWrappedObject, const QPointF& pos, bool onlySelectable = false) const; + int itemCount(QCustomPlot* theWrappedObject) const; + QCPLayer* layer(QCustomPlot* theWrappedObject, const QString& name) const; + QCPLayer* layer(QCustomPlot* theWrappedObject, int index) const; + int layerCount(QCustomPlot* theWrappedObject) const; + QCPLayerable* layerableAt(QCustomPlot* theWrappedObject, const QPointF& pos, bool onlySelectable, QVariant* selectionDetails = 0) const; + QCPLayoutElement* layoutElementAt(QCustomPlot* theWrappedObject, const QPointF& pos) const; + void legendRemoved(QCustomPlot* theWrappedObject, QCPLegend* legend); + QSize minimumSizeHint(QCustomPlot* theWrappedObject) const; + void mouseDoubleClickEvent(QCustomPlot* theWrappedObject, QMouseEvent* event); + void mouseMoveEvent(QCustomPlot* theWrappedObject, QMouseEvent* event); + void mousePressEvent(QCustomPlot* theWrappedObject, QMouseEvent* event); + void mouseReleaseEvent(QCustomPlot* theWrappedObject, QMouseEvent* event); + Qt::KeyboardModifier multiSelectModifier(QCustomPlot* theWrappedObject) const; + bool noAntialiasingOnDrag(QCustomPlot* theWrappedObject) const; + void paintEvent(QCustomPlot* theWrappedObject, QPaintEvent* event); + int plottableCount(QCustomPlot* theWrappedObject) const; + bool removeGraph(QCustomPlot* theWrappedObject, QCPGraph* graph); + bool removeGraph(QCustomPlot* theWrappedObject, int index); + bool removeItem(QCustomPlot* theWrappedObject, QCPAbstractItem* item); + bool removeItem(QCustomPlot* theWrappedObject, int index); + bool removeLayer(QCustomPlot* theWrappedObject, QCPLayer* layer); + bool removePlottable(QCustomPlot* theWrappedObject, int index); + void rescaleAxes(QCustomPlot* theWrappedObject, bool onlyVisiblePlottables = false); + void resizeEvent(QCustomPlot* theWrappedObject, QResizeEvent* event); + bool saveBmp(QCustomPlot* theWrappedObject, const QString& fileName, int width = 0, int height = 0, double scale = 1.0); + bool saveJpg(QCustomPlot* theWrappedObject, const QString& fileName, int width = 0, int height = 0, double scale = 1.0, int quality = -1); + bool savePdf(QCustomPlot* theWrappedObject, const QString& fileName, bool noCosmeticPen = false, int width = 0, int height = 0, const QString& pdfCreator = QString(), const QString& pdfTitle = QString()); + bool savePng(QCustomPlot* theWrappedObject, const QString& fileName, int width = 0, int height = 0, double scale = 1.0, int quality = -1); + bool saveRastered(QCustomPlot* theWrappedObject, const QString& fileName, int width, int height, double scale, const char* format, int quality = -1); + QList selectedAxes(QCustomPlot* theWrappedObject) const; + QList selectedGraphs(QCustomPlot* theWrappedObject) const; + QList selectedItems(QCustomPlot* theWrappedObject) const; + QList selectedLegends(QCustomPlot* theWrappedObject) const; + int selectionTolerance(QCustomPlot* theWrappedObject) const; + void setAutoAddPlottableToLegend(QCustomPlot* theWrappedObject, bool on); + void setBackground(QCustomPlot* theWrappedObject, const QBrush& brush); + void setBackground(QCustomPlot* theWrappedObject, const QPixmap& pm); + void setBackground(QCustomPlot* theWrappedObject, const QPixmap& pm, bool scaled, Qt::AspectRatioMode mode = Qt::KeepAspectRatioByExpanding); + void setBackgroundScaled(QCustomPlot* theWrappedObject, bool scaled); + void setBackgroundScaledMode(QCustomPlot* theWrappedObject, Qt::AspectRatioMode mode); + bool setCurrentLayer(QCustomPlot* theWrappedObject, QCPLayer* layer); + bool setCurrentLayer(QCustomPlot* theWrappedObject, const QString& name); + void setMultiSelectModifier(QCustomPlot* theWrappedObject, Qt::KeyboardModifier modifier); + void setNoAntialiasingOnDrag(QCustomPlot* theWrappedObject, bool enabled); + void setSelectionTolerance(QCustomPlot* theWrappedObject, int pixels); + void setViewport(QCustomPlot* theWrappedObject, const QRect& rect); + QSize sizeHint(QCustomPlot* theWrappedObject) const; + void toPainter(QCustomPlot* theWrappedObject, QCPPainter* painter, int width = 0, int height = 0); + QPixmap toPixmap(QCustomPlot* theWrappedObject, int width = 0, int height = 0, double scale = 1.0); + void updateLayerIndices(QCustomPlot* theWrappedObject) const; + QRect viewport(QCustomPlot* theWrappedObject) const; + void wheelEvent(QCustomPlot* theWrappedObject, QWheelEvent* event); +void py_set_legend(QCustomPlot* theWrappedObject, QCPLegend* legend){ theWrappedObject->legend = legend; } +QCPLegend* py_get_legend(QCustomPlot* theWrappedObject){ return theWrappedObject->legend; } +void py_set_xAxis(QCustomPlot* theWrappedObject, QCPAxis* xAxis){ theWrappedObject->xAxis = xAxis; } +QCPAxis* py_get_xAxis(QCustomPlot* theWrappedObject){ return theWrappedObject->xAxis; } +void py_set_xAxis2(QCustomPlot* theWrappedObject, QCPAxis* xAxis2){ theWrappedObject->xAxis2 = xAxis2; } +QCPAxis* py_get_xAxis2(QCustomPlot* theWrappedObject){ return theWrappedObject->xAxis2; } +void py_set_yAxis(QCustomPlot* theWrappedObject, QCPAxis* yAxis){ theWrappedObject->yAxis = yAxis; } +QCPAxis* py_get_yAxis(QCustomPlot* theWrappedObject){ return theWrappedObject->yAxis; } +void py_set_yAxis2(QCustomPlot* theWrappedObject, QCPAxis* yAxis2){ theWrappedObject->yAxis2 = yAxis2; } +QCPAxis* py_get_yAxis2(QCustomPlot* theWrappedObject){ return theWrappedObject->yAxis2; } +}; + + + + + +class PythonQtShell_QLopData : public QLopData +{ +public: + PythonQtShell_QLopData(QObject* parent = 0):QLopData(parent),_wrapper(NULL) { }; + + ~PythonQtShell_QLopData(); + +virtual void childEvent(QChildEvent* arg__1); +virtual void customEvent(QEvent* arg__1); +virtual bool event(QEvent* arg__1); +virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); +virtual void timerEvent(QTimerEvent* arg__1); + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtWrapper_QLopData : public QObject +{ Q_OBJECT +public: +public slots: +QLopData* new_QLopData(QObject* parent = 0); +void delete_QLopData(QLopData* obj) { delete obj; } +void py_set_name(QLopData* theWrappedObject, QString name){ theWrappedObject->name = name; } +QString py_get_name(QLopData* theWrappedObject){ return theWrappedObject->name; } +void py_set_unit(QLopData* theWrappedObject, QString unit){ theWrappedObject->unit = unit; } +QString py_get_unit(QLopData* theWrappedObject){ return theWrappedObject->unit; } +}; + + + + + +class PythonQtWrapper_QLopDataList : public QObject +{ Q_OBJECT +public: +public slots: +QLopDataList* new_QLopDataList(); +QLopDataList* new_QLopDataList(const QList& l); +void delete_QLopDataList(QLopDataList* obj) { delete obj; } + void append(QLopDataList* theWrappedObject, QLopData* t); + void append(QLopDataList* theWrappedObject, const QList& t); + QLopData* at(QLopDataList* theWrappedObject, int i) const; + QLopData* back(QLopDataList* theWrappedObject) const; + void clear(QLopDataList* theWrappedObject); + bool contains(QLopDataList* theWrappedObject, QLopData* t) const; + int count(QLopDataList* theWrappedObject) const; + int count(QLopDataList* theWrappedObject, QLopData* t) const; + void detachShared(QLopDataList* theWrappedObject); + bool empty(QLopDataList* theWrappedObject) const; + bool endsWith(QLopDataList* theWrappedObject, QLopData* t) const; + QLopData* first(QLopDataList* theWrappedObject) const; + QList static_QLopDataList_fromVector(const QVector& vector); + QLopData* front(QLopDataList* theWrappedObject) const; + int indexOf(QLopDataList* theWrappedObject, QLopData* t, int from = 0) const; + bool isEmpty(QLopDataList* theWrappedObject) const; + bool isSharedWith(QLopDataList* theWrappedObject, const QList& other) const; + QLopData* last(QLopDataList* theWrappedObject) const; + int lastIndexOf(QLopDataList* theWrappedObject, QLopData* t, int from = -1) const; + int length(QLopDataList* theWrappedObject) const; + QList mid(QLopDataList* theWrappedObject, int pos, int length = -1) const; + void move(QLopDataList* theWrappedObject, int from, int to); + bool __ne__(QLopDataList* theWrappedObject, const QList& l) const; + QList __add__(QLopDataList* theWrappedObject, const QList& l) const; + QList* __iadd__(QLopDataList* theWrappedObject, QLopData* t); + QList* __iadd__(QLopDataList* theWrappedObject, const QList& l); + QList* __lshift__(QLopDataList* theWrappedObject, QLopData* t); + QList* __lshift__(QLopDataList* theWrappedObject, const QList& l); + bool __eq__(QLopDataList* theWrappedObject, const QList& l) const; + void pop_back(QLopDataList* theWrappedObject); + void pop_front(QLopDataList* theWrappedObject); + void prepend(QLopDataList* theWrappedObject, QLopData* t); + void push_back(QLopDataList* theWrappedObject, QLopData* t); + void push_front(QLopDataList* theWrappedObject, QLopData* t); + int removeAll(QLopDataList* theWrappedObject, QLopData* t); + void removeAt(QLopDataList* theWrappedObject, int i); + void removeFirst(QLopDataList* theWrappedObject); + void removeLast(QLopDataList* theWrappedObject); + bool removeOne(QLopDataList* theWrappedObject, QLopData* t); + void replace(QLopDataList* theWrappedObject, int i, QLopData* t); + void reserve(QLopDataList* theWrappedObject, int size); + void setSharable(QLopDataList* theWrappedObject, bool sharable); + int size(QLopDataList* theWrappedObject) const; + bool startsWith(QLopDataList* theWrappedObject, QLopData* t) const; + void swap(QLopDataList* theWrappedObject, QList& other); + void swap(QLopDataList* theWrappedObject, int i, int j); + QLopData* takeAt(QLopDataList* theWrappedObject, int i); + QLopData* takeFirst(QLopDataList* theWrappedObject); + QLopData* takeLast(QLopDataList* theWrappedObject); + QVector toVector(QLopDataList* theWrappedObject) const; + QLopData* value(QLopDataList* theWrappedObject, int i) const; + QLopData* value(QLopDataList* theWrappedObject, int i, QLopData* defaultValue) const; +}; + + + + + class PythonQtShell_QLopService : public QLopService { public: diff --git a/src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop_init.cpp b/src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop_init.cpp --- a/src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop_init.cpp +++ b/src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop_init.cpp @@ -5,8 +5,29 @@ void PythonQt_init_PyQLop(PyObject* module) { +PythonQt::priv()->registerClass(&FileBrowser::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPAbstractItem::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPAbstractLegendItem::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPAxis::staticMetaObject, "PyQLop", PythonQtCreateObject, NULL, module, 0); +PythonQt::priv()->registerClass(&QCPAxisRect::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPBars::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPColorMap::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPColorScale::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPGraph::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerCPPClass("QCPItemPosition", "", "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPLayer::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPLayerable::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPLayout::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPLayoutElement::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPLegend::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerCPPClass("QCPPainter", "QPainter", "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCPPlotTitle::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QCustomPlot::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QLopData::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerCPPClass("QLopDataList", "", "PyQLop", PythonQtCreateObject, NULL, module, PythonQt::Type_Add|PythonQt::Type_InplaceAdd|PythonQt::Type_RichCompare); PythonQt::priv()->registerClass(&QLopService::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); PythonQt::priv()->registerClass(&SocExplorerPlot::staticMetaObject, "PyQLop", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQtRegisterListTemplateConverterForKnownClass(QVector, QString); } diff --git a/src/Core/pythonQtgeneratorCfg.txt b/src/Core/pythonQtgeneratorCfg.txt --- a/src/Core/pythonQtgeneratorCfg.txt +++ b/src/Core/pythonQtgeneratorCfg.txt @@ -4,7 +4,28 @@ - + + + + + + ; + ; + ; + ; + ; + ; + ; + ; + ; + ; + ; + ; + ; + ; + ; + ; + ; diff --git a/src/Core/pythongenerator.sh b/src/Core/pythongenerator.sh --- a/src/Core/pythongenerator.sh +++ b/src/Core/pythongenerator.sh @@ -3,4 +3,4 @@ #export QTDIR=/usr/include #export QTDIR=/usr/include/qt5 -pythonqt_generator --include-paths=../:./Widgets:./:/usr/include/qt5:/usr/include/qt5/QtCore:/usr/include/qt5/QtWidgets --output-directory=pythonQtOut pyqlop.h pythonQtgeneratorCfg.txt +pythonqt_generator --include-paths=../QCustomPlot:../:./Widgets:./:/usr/include/qt5:/usr/include/qt5/QtCore:/usr/include/qt5/QtWidgets --output-directory=pythonQtOut pyqlop.h pythonQtgeneratorCfg.txt diff --git a/src/SocExplorerPlot.cpp b/src/SocExplorerPlot.cpp --- a/src/SocExplorerPlot.cpp +++ b/src/SocExplorerPlot.cpp @@ -74,13 +74,15 @@ void SocExplorerPlot::exportToSVG(const void SocExplorerPlot::exportToPDF(const QString &fileName) { -// QPrinter printer; -// printer.setOutputFormat(QPrinter::PdfFormat); -// printer.setOutputFileName(fileName); -// QCPPainter qcpPainter; -// qcpPainter.begin(&printer); -// m_plot->toPainter(&qcpPainter, m_plot->width(), m_plot->height()); -// qcpPainter.end(); + QPrinter printer(QPrinter::HighResolution); + printer.setOutputFormat(QPrinter::PdfFormat); + printer.setOrientation(QPrinter::Landscape); + printer.setOutputFileName(fileName); + printer.setFullPage(true); + QCPPainter qcpPainter; + qcpPainter.begin(&printer); + m_plot->toPainter(&qcpPainter, printer.width(), printer.height()); + qcpPainter.end(); } void SocExplorerPlot::setTitle(QString title) @@ -90,7 +92,8 @@ void SocExplorerPlot::setTitle(QString t /*! @todo Function borcken fixe this! */ - this->repaint(); + emit titleChanged(title); + this->repaint(); } void SocExplorerPlot::setXaxisLabel(QString label) diff --git a/src/SocExplorerPlot.h b/src/SocExplorerPlot.h --- a/src/SocExplorerPlot.h +++ b/src/SocExplorerPlot.h @@ -64,7 +64,7 @@ public: void exportToSVG(const QString& fileName); void exportToPDF(const QString& fileName); signals: - + void titleChanged(const QString& newTitle); public slots: protected: diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp --- a/src/mainwindow.cpp +++ b/src/mainwindow.cpp @@ -45,8 +45,8 @@ MainWindow::MainWindow(int OMP_THREADS, this->OMP_THREADS = OMP_THREADS; ui->setupUi(this); - QLopPlots::getPlot()->setXaxisTickLabelType(QCPAxis::ltDateTime); - QLopPlots::getPlot()->setXaxisDateTimeFormat("hh:mm:ss.zzz"); +// QLopPlots::getPlot()->setXaxisTickLabelType(QCPAxis::ltDateTime); +// QLopPlots::getPlot()->setXaxisDateTimeFormat("hh:mm:ss.zzz"); this->progressWidget = new QWidget(); this->progressLayout = new QVBoxLayout(this->progressWidget); this->progressWidget->setLayout(this->progressLayout);