|
|
#include <PythonQt.h>
|
|
|
#include <QObject>
|
|
|
#include <QVariant>
|
|
|
#include <SocExplorerPlot.h>
|
|
|
#include <filebrowser.h>
|
|
|
#include <qabstractitemmodel.h>
|
|
|
#include <qaction.h>
|
|
|
#include <qbackingstore.h>
|
|
|
#include <qbitmap.h>
|
|
|
#include <qbrush.h>
|
|
|
#include <qbytearray.h>
|
|
|
#include <qcolor.h>
|
|
|
#include <qcoreevent.h>
|
|
|
#include <qcursor.h>
|
|
|
#include <qcustomplot.h>
|
|
|
#include <qdockwidget.h>
|
|
|
#include <qevent.h>
|
|
|
#include <qfont.h>
|
|
|
#include <qfontinfo.h>
|
|
|
#include <qfontmetrics.h>
|
|
|
#include <qglyphrun.h>
|
|
|
#include <qgraphicseffect.h>
|
|
|
#include <qgraphicsproxywidget.h>
|
|
|
#include <qicon.h>
|
|
|
#include <qimage.h>
|
|
|
#include <qkeysequence.h>
|
|
|
#include <qlayout.h>
|
|
|
#include <qline.h>
|
|
|
#include <qlist.h>
|
|
|
#include <qlocale.h>
|
|
|
#include <qlopdata.h>
|
|
|
#include <qlopservice.h>
|
|
|
#include <qmargins.h>
|
|
|
#include <qmatrix.h>
|
|
|
#include <qmetaobject.h>
|
|
|
#include <qobject.h>
|
|
|
#include <qpaintdevice.h>
|
|
|
#include <qpaintengine.h>
|
|
|
#include <qpainter.h>
|
|
|
#include <qpainterpath.h>
|
|
|
#include <qpalette.h>
|
|
|
#include <qpen.h>
|
|
|
#include <qpicture.h>
|
|
|
#include <qpixmap.h>
|
|
|
#include <qpoint.h>
|
|
|
#include <qpolygon.h>
|
|
|
#include <qrect.h>
|
|
|
#include <qregion.h>
|
|
|
#include <qsize.h>
|
|
|
#include <qsizepolicy.h>
|
|
|
#include <qstatictext.h>
|
|
|
#include <qstringlist.h>
|
|
|
#include <qstyle.h>
|
|
|
#include <qstyleoption.h>
|
|
|
#include <qtextoption.h>
|
|
|
#include <qtransform.h>
|
|
|
#include <qvector.h>
|
|
|
#include <qwidget.h>
|
|
|
#include <qwindow.h>
|
|
|
|
|
|
|
|
|
|
|
|
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<QCPItemPosition* > 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<QCPLayoutElement* > 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<QCPGraph* > graphs(QCPAxis* theWrappedObject) const;
|
|
|
QList<QCPAbstractItem* > 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<double >& vec);
|
|
|
void setTickVectorLabels(QCPAxis* theWrappedObject, const QVector<QString >& 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<double > tickVector(QCPAxis* theWrappedObject) const;
|
|
|
QVector<QString > 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<QCPLayoutElement* > 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<QCPLayoutElement* > 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<QCPAxis* > 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<QCPLayoutElement* > elements(QCPAxisRect* theWrappedObject, bool recursive) const;
|
|
|
QList<QCPGraph* > graphs(QCPAxisRect* theWrappedObject) const;
|
|
|
int height(QCPAxisRect* theWrappedObject) const;
|
|
|
QList<QCPAbstractItem* > 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<double >& keys, const QVector<double >& 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<double >& key, const QVector<double >& 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<QCPLayoutElement* > 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<QCPColorMap* > 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<QPointF >* lineData) const;
|
|
|
virtual void drawImpulsePlot(QCPPainter* painter, QVector<QPointF >* lineData) const;
|
|
|
virtual void drawLegendIcon(QCPPainter* painter, const QRectF& rect) const;
|
|
|
virtual void drawLinePlot(QCPPainter* painter, QVector<QPointF >* 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<QPointF >* 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<QPointF >* lineData) const { QCPGraph::drawFill(painter, lineData); }
|
|
|
inline void promoted_drawImpulsePlot(QCPPainter* painter, QVector<QPointF >* 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<QPointF >* lineData) const { QCPGraph::drawLinePlot(painter, lineData); }
|
|
|
inline int promoted_findIndexAboveX(const QVector<QPointF >* data, double x) const { return QCPGraph::findIndexAboveX(data, x); }
|
|
|
inline int promoted_findIndexAboveY(const QVector<QPointF >* data, double y) const { return QCPGraph::findIndexAboveY(data, y); }
|
|
|
inline int promoted_findIndexBelowX(const QVector<QPointF >* data, double x) const { return QCPGraph::findIndexBelowX(data, x); }
|
|
|
inline int promoted_findIndexBelowY(const QVector<QPointF >* data, double y) const { return QCPGraph::findIndexBelowY(data, y); }
|
|
|
inline const QPolygonF promoted_getChannelFillPolygon(const QVector<QPointF >* 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<QPointF >* 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<double >& keys, const QVector<double >& values);
|
|
|
void addData(QCPGraph* theWrappedObject, double key, double value);
|
|
|
void addFillBasePoints(QCPGraph* theWrappedObject, QVector<QPointF >* lineData) const;
|
|
|
QCPGraph* channelFillGraph(QCPGraph* theWrappedObject) const;
|
|
|
void clearData(QCPGraph* theWrappedObject);
|
|
|
void draw(QCPGraph* theWrappedObject, QCPPainter* painter);
|
|
|
void drawFill(QCPGraph* theWrappedObject, QCPPainter* painter, QVector<QPointF >* lineData) const;
|
|
|
void drawImpulsePlot(QCPGraph* theWrappedObject, QCPPainter* painter, QVector<QPointF >* lineData) const;
|
|
|
void drawLegendIcon(QCPGraph* theWrappedObject, QCPPainter* painter, const QRectF& rect) const;
|
|
|
void drawLinePlot(QCPGraph* theWrappedObject, QCPPainter* painter, QVector<QPointF >* lineData) const;
|
|
|
double errorBarSize(QCPGraph* theWrappedObject) const;
|
|
|
bool errorBarSkipSymbol(QCPGraph* theWrappedObject) const;
|
|
|
QPen errorPen(QCPGraph* theWrappedObject) const;
|
|
|
int findIndexAboveX(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double x) const;
|
|
|
int findIndexAboveY(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double y) const;
|
|
|
int findIndexBelowX(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double x) const;
|
|
|
int findIndexBelowY(QCPGraph* theWrappedObject, const QVector<QPointF >* data, double y) const;
|
|
|
const QPolygonF getChannelFillPolygon(QCPGraph* theWrappedObject, const QVector<QPointF >* 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<QPointF >* 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<double >& key, const QVector<double >& value);
|
|
|
void setDataBothError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyError, const QVector<double >& valueError);
|
|
|
void setDataBothError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyErrorMinus, const QVector<double >& keyErrorPlus, const QVector<double >& valueErrorMinus, const QVector<double >& valueErrorPlus);
|
|
|
void setDataKeyError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyError);
|
|
|
void setDataKeyError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& keyErrorMinus, const QVector<double >& keyErrorPlus);
|
|
|
void setDataValueError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& valueError);
|
|
|
void setDataValueError(QCPGraph* theWrappedObject, const QVector<double >& key, const QVector<double >& value, const QVector<double >& valueErrorMinus, const QVector<double >& 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<QCPLayerable* > 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<QCPLayoutElement* > 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<QCPLayoutElement* > promoted_elements(bool recursive) const { return QCPLayout::elements(recursive); }
|
|
|
inline QVector<int > promoted_getSectionSizes(QVector<int > maxSizes, QVector<int > minSizes, QVector<double > 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<QCPLayoutElement* > elements(QCPLayout* theWrappedObject, bool recursive) const;
|
|
|
QVector<int > getSectionSizes(QCPLayout* theWrappedObject, QVector<int > maxSizes, QVector<int > minSizes, QVector<double > 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<QCPLayoutElement* > 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<QCPLayoutElement* > 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<QCPLayoutElement* > 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<QCPAbstractLegendItem* > 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<QCPLayoutElement* > 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<QCPAxisRect* > 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<QCPAxis* > selectedAxes(QCustomPlot* theWrappedObject) const;
|
|
|
QList<QCPGraph* > selectedGraphs(QCustomPlot* theWrappedObject) const;
|
|
|
QList<QCPAbstractItem* > selectedItems(QCustomPlot* theWrappedObject) const;
|
|
|
QList<QCPLegend* > 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<QLopData* >& l);
|
|
|
void delete_QLopDataList(QLopDataList* obj) { delete obj; }
|
|
|
void append(QLopDataList* theWrappedObject, QLopData* t);
|
|
|
void append(QLopDataList* theWrappedObject, const QList<QLopData* >& 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<QLopData* > static_QLopDataList_fromVector(const QVector<QLopData* >& 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<QLopData* >& other) const;
|
|
|
QLopData* last(QLopDataList* theWrappedObject) const;
|
|
|
int lastIndexOf(QLopDataList* theWrappedObject, QLopData* t, int from = -1) const;
|
|
|
int length(QLopDataList* theWrappedObject) const;
|
|
|
QList<QLopData* > mid(QLopDataList* theWrappedObject, int pos, int length = -1) const;
|
|
|
void move(QLopDataList* theWrappedObject, int from, int to);
|
|
|
bool __ne__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) const;
|
|
|
QList<QLopData* > __add__(QLopDataList* theWrappedObject, const QList<QLopData* >& l) const;
|
|
|
QList<QLopData* >* __iadd__(QLopDataList* theWrappedObject, QLopData* t);
|
|
|
QList<QLopData* >* __iadd__(QLopDataList* theWrappedObject, const QList<QLopData* >& l);
|
|
|
QList<QLopData* >* __lshift__(QLopDataList* theWrappedObject, QLopData* t);
|
|
|
QList<QLopData* >* __lshift__(QLopDataList* theWrappedObject, const QList<QLopData* >& l);
|
|
|
bool __eq__(QLopDataList* theWrappedObject, const QList<QLopData* >& 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<QLopData* >& other);
|
|
|
void swap(QLopDataList* theWrappedObject, int i, int j);
|
|
|
QLopData* takeAt(QLopDataList* theWrappedObject, int i);
|
|
|
QLopData* takeFirst(QLopDataList* theWrappedObject);
|
|
|
QLopData* takeLast(QLopDataList* theWrappedObject);
|
|
|
QVector<QLopData* > 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:
|
|
|
PythonQtShell_QLopService(QObject* parent = 0):QLopService(parent),_wrapper(NULL) { };
|
|
|
|
|
|
~PythonQtShell_QLopService();
|
|
|
|
|
|
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 QDockWidget* getGUI();
|
|
|
virtual const QString& serviceName();
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QLopService : public QLopService
|
|
|
{ public:
|
|
|
inline QDockWidget* promoted_getGUI() { return getGUI(); }
|
|
|
inline const QString& promoted_serviceName() { return QLopService::serviceName(); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QLopService : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QLopService* new_QLopService(QObject* parent = 0);
|
|
|
void delete_QLopService(QLopService* obj) { delete obj; }
|
|
|
QDockWidget* getGUI(QLopService* theWrappedObject);
|
|
|
const QString* serviceName(QLopService* theWrappedObject);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) { };
|
|
|
|
|
|
~PythonQtShell_SocExplorerPlot();
|
|
|
|
|
|
virtual void actionEvent(QActionEvent* arg__1);
|
|
|
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 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 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* arg__1);
|
|
|
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_SocExplorerPlot : public SocExplorerPlot
|
|
|
{ public:
|
|
|
inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
|
|
|
inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
|
|
|
inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
|
|
|
inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
|
|
|
inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
|
|
|
inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_SocExplorerPlot : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
|
|
|
void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
|
|
|
int addGraph(SocExplorerPlot* theWrappedObject);
|
|
|
void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
|
|
|
void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
|
|
|
void exportToPDF(SocExplorerPlot* theWrappedObject, const QString& fileName);
|
|
|
void exportToSVG(SocExplorerPlot* theWrappedObject, const QString& fileName);
|
|
|
QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
|
|
|
void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
|
|
|
void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
|
|
|
void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
|
|
|
void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
|
|
|
void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
|
|
|
void removeAllGraphs(SocExplorerPlot* theWrappedObject);
|
|
|
bool removeGraph(SocExplorerPlot* theWrappedObject, int graphIndex);
|
|
|
void replot(SocExplorerPlot* theWrappedObject);
|
|
|
void rescaleAxis(SocExplorerPlot* theWrappedObject);
|
|
|
void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
|
|
|
void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
|
|
|
void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
|
|
|
void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
|
|
|
void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
|
|
|
void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
|
|
|
void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
|
|
|
void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
|
|
|
void setTitle(SocExplorerPlot* theWrappedObject, QString title);
|
|
|
void setUseFastVector(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
|
|
|
void setXaxisDateTimeFormat(SocExplorerPlot* theWrappedObject, const QString& format);
|
|
|
void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
|
|
|
void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
|
|
|
void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
|
|
|
void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
|
|
|
void show(SocExplorerPlot* theWrappedObject);
|
|
|
void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
