|
|
#include <PythonQt.h>
|
|
|
#include <QColor>
|
|
|
#include <QIconEngine>
|
|
|
#include <QImage>
|
|
|
#include <QObject>
|
|
|
#include <QPainterPath>
|
|
|
#include <QRect>
|
|
|
#include <QSize>
|
|
|
#include <QStringList>
|
|
|
#include <QTextCursor>
|
|
|
#include <QVarLengthArray>
|
|
|
#include <QVariant>
|
|
|
#include <qabstractanimation.h>
|
|
|
#include <qabstractitemdelegate.h>
|
|
|
#include <qabstractitemmodel.h>
|
|
|
#include <qabstractitemview.h>
|
|
|
#include <qabstractstate.h>
|
|
|
#include <qaction.h>
|
|
|
#include <qbitmap.h>
|
|
|
#include <qboxlayout.h>
|
|
|
#include <qbrush.h>
|
|
|
#include <qbytearray.h>
|
|
|
#include <qclipboard.h>
|
|
|
#include <qcolor.h>
|
|
|
#include <qcoreapplication.h>
|
|
|
#include <qcoreevent.h>
|
|
|
#include <qcursor.h>
|
|
|
#include <qevent.h>
|
|
|
#include <qfont.h>
|
|
|
#include <qgraphicseffect.h>
|
|
|
#include <qgraphicsitem.h>
|
|
|
#include <qgraphicslayout.h>
|
|
|
#include <qgraphicslayoutitem.h>
|
|
|
#include <qgraphicsproxywidget.h>
|
|
|
#include <qgraphicsscene.h>
|
|
|
#include <qgraphicssceneevent.h>
|
|
|
#include <qgraphicstransform.h>
|
|
|
#include <qgraphicsview.h>
|
|
|
#include <qgraphicswidget.h>
|
|
|
#include <qgridlayout.h>
|
|
|
#include <qgroupbox.h>
|
|
|
#include <qguiapplication.h>
|
|
|
#include <qheaderview.h>
|
|
|
#include <qimage.h>
|
|
|
#include <qimageiohandler.h>
|
|
|
#include <qimagereader.h>
|
|
|
#include <qimagewriter.h>
|
|
|
#include <qinputdialog.h>
|
|
|
#include <qiodevice.h>
|
|
|
#include <qitemdelegate.h>
|
|
|
#include <qitemeditorfactory.h>
|
|
|
#include <qitemselectionmodel.h>
|
|
|
#include <qkeyeventtransition.h>
|
|
|
#include <qkeysequence.h>
|
|
|
#include <qlayout.h>
|
|
|
#include <qlayoutitem.h>
|
|
|
#include <qlist.h>
|
|
|
#include <qlocale.h>
|
|
|
#include <qmargins.h>
|
|
|
#include <qmatrix.h>
|
|
|
#include <qmatrix4x4.h>
|
|
|
#include <qobject.h>
|
|
|
#include <qpaintdevice.h>
|
|
|
#include <qpaintengine.h>
|
|
|
#include <qpainter.h>
|
|
|
#include <qpainterpath.h>
|
|
|
#include <qpalette.h>
|
|
|
#include <qpen.h>
|
|
|
#include <qpixmap.h>
|
|
|
#include <qpoint.h>
|
|
|
#include <qpolygon.h>
|
|
|
#include <qrect.h>
|
|
|
#include <qregion.h>
|
|
|
#include <qscrollbar.h>
|
|
|
#include <qsessionmanager.h>
|
|
|
#include <qsize.h>
|
|
|
#include <qsizepolicy.h>
|
|
|
#include <qstate.h>
|
|
|
#include <qstatemachine.h>
|
|
|
#include <qstringlist.h>
|
|
|
#include <qstyle.h>
|
|
|
#include <qstyleoption.h>
|
|
|
#include <qtextcursor.h>
|
|
|
#include <qtextdocument.h>
|
|
|
#include <qtransform.h>
|
|
|
#include <qtranslator.h>
|
|
|
#include <qvalidator.h>
|
|
|
#include <qvector.h>
|
|
|
#include <qwidget.h>
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QGraphicsSceneWheelEvent : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QGraphicsSceneWheelEvent* new_QGraphicsSceneWheelEvent(QEvent::Type type = QEvent::None);
|
|
|
void delete_QGraphicsSceneWheelEvent(QGraphicsSceneWheelEvent* obj) { delete obj; }
|
|
|
Qt::MouseButtons buttons(QGraphicsSceneWheelEvent* theWrappedObject) const;
|
|
|
int delta(QGraphicsSceneWheelEvent* theWrappedObject) const;
|
|
|
Qt::KeyboardModifiers modifiers(QGraphicsSceneWheelEvent* theWrappedObject) const;
|
|
|
Qt::Orientation orientation(QGraphicsSceneWheelEvent* theWrappedObject) const;
|
|
|
QPointF pos(QGraphicsSceneWheelEvent* theWrappedObject) const;
|
|
|
QPointF scenePos(QGraphicsSceneWheelEvent* theWrappedObject) const;
|
|
|
QPoint screenPos(QGraphicsSceneWheelEvent* theWrappedObject) const;
|
|
|
void setButtons(QGraphicsSceneWheelEvent* theWrappedObject, Qt::MouseButtons buttons);
|
|
|
void setDelta(QGraphicsSceneWheelEvent* theWrappedObject, int delta);
|
|
|
void setModifiers(QGraphicsSceneWheelEvent* theWrappedObject, Qt::KeyboardModifiers modifiers);
|
|
|
void setOrientation(QGraphicsSceneWheelEvent* theWrappedObject, Qt::Orientation orientation);
|
|
|
void setPos(QGraphicsSceneWheelEvent* theWrappedObject, const QPointF& pos);
|
|
|
void setScenePos(QGraphicsSceneWheelEvent* theWrappedObject, const QPointF& pos);
|
|
|
void setScreenPos(QGraphicsSceneWheelEvent* theWrappedObject, const QPoint& pos);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGraphicsSimpleTextItem : public QGraphicsSimpleTextItem
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGraphicsSimpleTextItem(QGraphicsItem* parent = 0):QGraphicsSimpleTextItem(parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGraphicsSimpleTextItem(const QString& text, QGraphicsItem* parent = 0):QGraphicsSimpleTextItem(text, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGraphicsSimpleTextItem();
|
|
|
|
|
|
virtual bool isObscuredBy(const QGraphicsItem* item) const;
|
|
|
virtual QPainterPath opaqueArea() const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QGraphicsSimpleTextItem : public QGraphicsSimpleTextItem
|
|
|
{ public:
|
|
|
inline bool promoted_isObscuredBy(const QGraphicsItem* item) const { return QGraphicsSimpleTextItem::isObscuredBy(item); }
|
|
|
inline QPainterPath promoted_opaqueArea() const { return QGraphicsSimpleTextItem::opaqueArea(); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGraphicsSimpleTextItem : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(enum_1 )
|
|
|
enum enum_1{
|
|
|
Type = QGraphicsSimpleTextItem::Type};
|
|
|
public slots:
|
|
|
QGraphicsSimpleTextItem* new_QGraphicsSimpleTextItem(QGraphicsItem* parent = 0);
|
|
|
QGraphicsSimpleTextItem* new_QGraphicsSimpleTextItem(const QString& text, QGraphicsItem* parent = 0);
|
|
|
void delete_QGraphicsSimpleTextItem(QGraphicsSimpleTextItem* obj) { delete obj; }
|
|
|
QRectF boundingRect(QGraphicsSimpleTextItem* theWrappedObject) const;
|
|
|
bool contains(QGraphicsSimpleTextItem* theWrappedObject, const QPointF& point) const;
|
|
|
QFont font(QGraphicsSimpleTextItem* theWrappedObject) const;
|
|
|
bool isObscuredBy(QGraphicsSimpleTextItem* theWrappedObject, const QGraphicsItem* item) const;
|
|
|
QPainterPath opaqueArea(QGraphicsSimpleTextItem* theWrappedObject) const;
|
|
|
void paint(QGraphicsSimpleTextItem* theWrappedObject, QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget);
|
|
|
void setFont(QGraphicsSimpleTextItem* theWrappedObject, const QFont& font);
|
|
|
void setText(QGraphicsSimpleTextItem* theWrappedObject, const QString& text);
|
|
|
QPainterPath shape(QGraphicsSimpleTextItem* theWrappedObject) const;
|
|
|
QString text(QGraphicsSimpleTextItem* theWrappedObject) const;
|
|
|
int type(QGraphicsSimpleTextItem* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGraphicsTextItem : public QGraphicsTextItem
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGraphicsTextItem(QGraphicsItem* parent = 0):QGraphicsTextItem(parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGraphicsTextItem(const QString& text, QGraphicsItem* parent = 0):QGraphicsTextItem(text, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGraphicsTextItem();
|
|
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* ev);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGraphicsTextItem : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(enum_1 )
|
|
|
enum enum_1{
|
|
|
Type = QGraphicsTextItem::Type};
|
|
|
public slots:
|
|
|
QGraphicsTextItem* new_QGraphicsTextItem(QGraphicsItem* parent = 0);
|
|
|
QGraphicsTextItem* new_QGraphicsTextItem(const QString& text, QGraphicsItem* parent = 0);
|
|
|
void delete_QGraphicsTextItem(QGraphicsTextItem* obj) { delete obj; }
|
|
|
void adjustSize(QGraphicsTextItem* theWrappedObject);
|
|
|
QRectF boundingRect(QGraphicsTextItem* theWrappedObject) const;
|
|
|
bool contains(QGraphicsTextItem* theWrappedObject, const QPointF& point) const;
|
|
|
QColor defaultTextColor(QGraphicsTextItem* theWrappedObject) const;
|
|
|
QTextDocument* document(QGraphicsTextItem* theWrappedObject) const;
|
|
|
QFont font(QGraphicsTextItem* theWrappedObject) const;
|
|
|
bool isObscuredBy(QGraphicsTextItem* theWrappedObject, const QGraphicsItem* item) const;
|
|
|
QPainterPath opaqueArea(QGraphicsTextItem* theWrappedObject) const;
|
|
|
bool openExternalLinks(QGraphicsTextItem* theWrappedObject) const;
|
|
|
void paint(QGraphicsTextItem* theWrappedObject, QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget);
|
|
|
void setDefaultTextColor(QGraphicsTextItem* theWrappedObject, const QColor& c);
|
|
|
void setDocument(QGraphicsTextItem* theWrappedObject, QTextDocument* document);
|
|
|
void setFont(QGraphicsTextItem* theWrappedObject, const QFont& font);
|
|
|
void setHtml(QGraphicsTextItem* theWrappedObject, const QString& html);
|
|
|
void setOpenExternalLinks(QGraphicsTextItem* theWrappedObject, bool open);
|
|
|
void setPlainText(QGraphicsTextItem* theWrappedObject, const QString& text);
|
|
|
void setTabChangesFocus(QGraphicsTextItem* theWrappedObject, bool b);
|
|
|
void setTextCursor(QGraphicsTextItem* theWrappedObject, const QTextCursor& cursor);
|
|
|
void setTextInteractionFlags(QGraphicsTextItem* theWrappedObject, Qt::TextInteractionFlags flags);
|
|
|
void setTextWidth(QGraphicsTextItem* theWrappedObject, qreal width);
|
|
|
QPainterPath shape(QGraphicsTextItem* theWrappedObject) const;
|
|
|
bool tabChangesFocus(QGraphicsTextItem* theWrappedObject) const;
|
|
|
QTextCursor textCursor(QGraphicsTextItem* theWrappedObject) const;
|
|
|
Qt::TextInteractionFlags textInteractionFlags(QGraphicsTextItem* theWrappedObject) const;
|
|
|
qreal textWidth(QGraphicsTextItem* theWrappedObject) const;
|
|
|
QString toHtml(QGraphicsTextItem* theWrappedObject) const;
|
|
|
QString toPlainText(QGraphicsTextItem* theWrappedObject) const;
|
|
|
int type(QGraphicsTextItem* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGraphicsTransform : public QGraphicsTransform
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGraphicsTransform(QObject* parent = 0):QGraphicsTransform(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGraphicsTransform();
|
|
|
|
|
|
virtual void applyTo(QMatrix4x4* matrix) const;
|
|
|
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_QGraphicsTransform : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QGraphicsTransform* new_QGraphicsTransform(QObject* parent = 0);
|
|
|
void delete_QGraphicsTransform(QGraphicsTransform* obj) { delete obj; }
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGraphicsView : public QGraphicsView
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGraphicsView(QGraphicsScene* scene, QWidget* parent = 0):QGraphicsView(scene, parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGraphicsView(QWidget* parent = 0):QGraphicsView(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGraphicsView();
|
|
|
|
|
|
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* event);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual int devType() const;
|
|
|
virtual void dragEnterEvent(QDragEnterEvent* event);
|
|
|
virtual void dragLeaveEvent(QDragLeaveEvent* event);
|
|
|
virtual void dragMoveEvent(QDragMoveEvent* event);
|
|
|
virtual void drawBackground(QPainter* painter, const QRectF& rect);
|
|
|
virtual void drawForeground(QPainter* painter, const QRectF& rect);
|
|
|
virtual void drawItems(QPainter* painter, int numItems, QGraphicsItem** items, const QStyleOptionGraphicsItem* options);
|
|
|
virtual void dropEvent(QDropEvent* event);
|
|
|
virtual void enterEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* event);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void focusInEvent(QFocusEvent* event);
|
|
|
virtual bool focusNextPrevChild(bool next);
|
|
|
virtual void focusOutEvent(QFocusEvent* event);
|
|
|
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* event);
|
|
|
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
|
|
|
virtual void keyPressEvent(QKeyEvent* event);
|
|
|
virtual void keyReleaseEvent(QKeyEvent* event);
|
|
|
virtual void leaveEvent(QEvent* arg__1);
|
|
|
virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) 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 void scrollContentsBy(int dx, int dy);
|
|
|
virtual void setupViewport(QWidget* widget);
|
|
|
virtual QPainter* sharedPainter() const;
|
|
|
virtual void showEvent(QShowEvent* event);
|
|
|
virtual void tabletEvent(QTabletEvent* arg__1);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
virtual bool viewportEvent(QEvent* event);
|
|
|
virtual QSize viewportSizeHint() const;
|
|
|
virtual void wheelEvent(QWheelEvent* event);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QGraphicsView : public QGraphicsView
|
|
|
{ public:
|
|
|
inline void promoted_contextMenuEvent(QContextMenuEvent* event) { QGraphicsView::contextMenuEvent(event); }
|
|
|
inline void promoted_dragEnterEvent(QDragEnterEvent* event) { QGraphicsView::dragEnterEvent(event); }
|
|
|
inline void promoted_dragLeaveEvent(QDragLeaveEvent* event) { QGraphicsView::dragLeaveEvent(event); }
|
|
|
inline void promoted_dragMoveEvent(QDragMoveEvent* event) { QGraphicsView::dragMoveEvent(event); }
|
|
|
inline void promoted_drawBackground(QPainter* painter, const QRectF& rect) { QGraphicsView::drawBackground(painter, rect); }
|
|
|
inline void promoted_drawForeground(QPainter* painter, const QRectF& rect) { QGraphicsView::drawForeground(painter, rect); }
|
|
|
inline void promoted_drawItems(QPainter* painter, int numItems, QGraphicsItem** items, const QStyleOptionGraphicsItem* options) { QGraphicsView::drawItems(painter, numItems, items, options); }
|
|
|
inline void promoted_dropEvent(QDropEvent* event) { QGraphicsView::dropEvent(event); }
|
|
|
inline bool promoted_event(QEvent* event) { return QGraphicsView::event(event); }
|
|
|
inline void promoted_focusInEvent(QFocusEvent* event) { QGraphicsView::focusInEvent(event); }
|
|
|
inline bool promoted_focusNextPrevChild(bool next) { return QGraphicsView::focusNextPrevChild(next); }
|
|
|
inline void promoted_focusOutEvent(QFocusEvent* event) { QGraphicsView::focusOutEvent(event); }
|
|
|
inline void promoted_inputMethodEvent(QInputMethodEvent* event) { QGraphicsView::inputMethodEvent(event); }
|
|
|
inline QVariant promoted_inputMethodQuery(Qt::InputMethodQuery query) const { return QGraphicsView::inputMethodQuery(query); }
|
|
|
inline void promoted_keyPressEvent(QKeyEvent* event) { QGraphicsView::keyPressEvent(event); }
|
|
|
inline void promoted_keyReleaseEvent(QKeyEvent* event) { QGraphicsView::keyReleaseEvent(event); }
|
|
|
inline void promoted_mouseDoubleClickEvent(QMouseEvent* event) { QGraphicsView::mouseDoubleClickEvent(event); }
|
|
|
inline void promoted_mouseMoveEvent(QMouseEvent* event) { QGraphicsView::mouseMoveEvent(event); }
|
|
|
inline void promoted_mousePressEvent(QMouseEvent* event) { QGraphicsView::mousePressEvent(event); }
|
|
|
inline void promoted_mouseReleaseEvent(QMouseEvent* event) { QGraphicsView::mouseReleaseEvent(event); }
|
|
|
inline void promoted_paintEvent(QPaintEvent* event) { QGraphicsView::paintEvent(event); }
|
|
|
inline void promoted_resizeEvent(QResizeEvent* event) { QGraphicsView::resizeEvent(event); }
|
|
|
inline void promoted_scrollContentsBy(int dx, int dy) { QGraphicsView::scrollContentsBy(dx, dy); }
|
|
|
inline void promoted_setupViewport(QWidget* widget) { QGraphicsView::setupViewport(widget); }
|
|
|
inline void promoted_showEvent(QShowEvent* event) { QGraphicsView::showEvent(event); }
|
|
|
inline bool promoted_viewportEvent(QEvent* event) { return QGraphicsView::viewportEvent(event); }
|
|
|
inline void promoted_wheelEvent(QWheelEvent* event) { QGraphicsView::wheelEvent(event); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGraphicsView : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(OptimizationFlag CacheModeFlag )
|
|
|
Q_FLAGS(OptimizationFlags CacheMode )
|
|
|
enum OptimizationFlag{
|
|
|
DontClipPainter = QGraphicsView::DontClipPainter, DontSavePainterState = QGraphicsView::DontSavePainterState, DontAdjustForAntialiasing = QGraphicsView::DontAdjustForAntialiasing, IndirectPainting = QGraphicsView::IndirectPainting};
|
|
|
enum CacheModeFlag{
|
|
|
CacheNone = QGraphicsView::CacheNone, CacheBackground = QGraphicsView::CacheBackground};
|
|
|
Q_DECLARE_FLAGS(OptimizationFlags, OptimizationFlag)
|
|
|
Q_DECLARE_FLAGS(CacheMode, CacheModeFlag)
|
|
|
public slots:
|
|
|
QGraphicsView* new_QGraphicsView(QGraphicsScene* scene, QWidget* parent = 0);
|
|
|
QGraphicsView* new_QGraphicsView(QWidget* parent = 0);
|
|
|
void delete_QGraphicsView(QGraphicsView* obj) { delete obj; }
|
|
|
Qt::Alignment alignment(QGraphicsView* theWrappedObject) const;
|
|
|
QBrush backgroundBrush(QGraphicsView* theWrappedObject) const;
|
|
|
QGraphicsView::CacheMode cacheMode(QGraphicsView* theWrappedObject) const;
|
|
|
void centerOn(QGraphicsView* theWrappedObject, const QGraphicsItem* item);
|
|
|
void centerOn(QGraphicsView* theWrappedObject, const QPointF& pos);
|
|
|
void centerOn(QGraphicsView* theWrappedObject, qreal x, qreal y);
|
|
|
void contextMenuEvent(QGraphicsView* theWrappedObject, QContextMenuEvent* event);
|
|
|
void dragEnterEvent(QGraphicsView* theWrappedObject, QDragEnterEvent* event);
|
|
|
void dragLeaveEvent(QGraphicsView* theWrappedObject, QDragLeaveEvent* event);
|
|
|
QGraphicsView::DragMode dragMode(QGraphicsView* theWrappedObject) const;
|
|
|
void dragMoveEvent(QGraphicsView* theWrappedObject, QDragMoveEvent* event);
|
|
|
void drawBackground(QGraphicsView* theWrappedObject, QPainter* painter, const QRectF& rect);
|
|
|
void drawForeground(QGraphicsView* theWrappedObject, QPainter* painter, const QRectF& rect);
|
|
|
void drawItems(QGraphicsView* theWrappedObject, QPainter* painter, int numItems, QGraphicsItem** items, const QStyleOptionGraphicsItem* options);
|
|
|
void dropEvent(QGraphicsView* theWrappedObject, QDropEvent* event);
|
|
|
void ensureVisible(QGraphicsView* theWrappedObject, const QGraphicsItem* item, int xmargin = 50, int ymargin = 50);
|
|
|
void ensureVisible(QGraphicsView* theWrappedObject, const QRectF& rect, int xmargin = 50, int ymargin = 50);
|
|
|
void ensureVisible(QGraphicsView* theWrappedObject, qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50);
|
|
|
bool event(QGraphicsView* theWrappedObject, QEvent* event);
|
|
|
void fitInView(QGraphicsView* theWrappedObject, const QGraphicsItem* item, Qt::AspectRatioMode aspectRadioMode = Qt::IgnoreAspectRatio);
|
|
|
void fitInView(QGraphicsView* theWrappedObject, const QRectF& rect, Qt::AspectRatioMode aspectRadioMode = Qt::IgnoreAspectRatio);
|
|
|
void fitInView(QGraphicsView* theWrappedObject, qreal x, qreal y, qreal w, qreal h, Qt::AspectRatioMode aspectRadioMode = Qt::IgnoreAspectRatio);
|
|
|
void focusInEvent(QGraphicsView* theWrappedObject, QFocusEvent* event);
|
|
|
bool focusNextPrevChild(QGraphicsView* theWrappedObject, bool next);
|
|
|
void focusOutEvent(QGraphicsView* theWrappedObject, QFocusEvent* event);
|
|
|
QBrush foregroundBrush(QGraphicsView* theWrappedObject) const;
|
|
|
void inputMethodEvent(QGraphicsView* theWrappedObject, QInputMethodEvent* event);
|
|
|
QVariant inputMethodQuery(QGraphicsView* theWrappedObject, Qt::InputMethodQuery query) const;
|
|
|
bool isInteractive(QGraphicsView* theWrappedObject) const;
|
|
|
bool isTransformed(QGraphicsView* theWrappedObject) const;
|
|
|
QGraphicsItem* itemAt(QGraphicsView* theWrappedObject, const QPoint& pos) const;
|
|
|
QGraphicsItem* itemAt(QGraphicsView* theWrappedObject, int x, int y) const;
|
|
|
QList<QGraphicsItem* > items(QGraphicsView* theWrappedObject) const;
|
|
|
QList<QGraphicsItem* > items(QGraphicsView* theWrappedObject, const QPainterPath& path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
|
|
|
QList<QGraphicsItem* > items(QGraphicsView* theWrappedObject, const QPoint& pos) const;
|
|
|
QList<QGraphicsItem* > items(QGraphicsView* theWrappedObject, const QPolygon& polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
|
|
|
QList<QGraphicsItem* > items(QGraphicsView* theWrappedObject, const QRect& rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
|
|
|
QList<QGraphicsItem* > items(QGraphicsView* theWrappedObject, int x, int y) const;
|
|
|
QList<QGraphicsItem* > items(QGraphicsView* theWrappedObject, int x, int y, int w, int h, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const;
|
|
|
void keyPressEvent(QGraphicsView* theWrappedObject, QKeyEvent* event);
|
|
|
void keyReleaseEvent(QGraphicsView* theWrappedObject, QKeyEvent* event);
|
|
|
QPainterPath mapFromScene(QGraphicsView* theWrappedObject, const QPainterPath& path) const;
|
|
|
QPoint mapFromScene(QGraphicsView* theWrappedObject, const QPointF& point) const;
|
|
|
QPolygon mapFromScene(QGraphicsView* theWrappedObject, const QPolygonF& polygon) const;
|
|
|
QPolygon mapFromScene(QGraphicsView* theWrappedObject, const QRectF& rect) const;
|
|
|
QPoint mapFromScene(QGraphicsView* theWrappedObject, qreal x, qreal y) const;
|
|
|
QPolygon mapFromScene(QGraphicsView* theWrappedObject, qreal x, qreal y, qreal w, qreal h) const;
|
|
|
QPainterPath mapToScene(QGraphicsView* theWrappedObject, const QPainterPath& path) const;
|
|
|
QPointF mapToScene(QGraphicsView* theWrappedObject, const QPoint& point) const;
|
|
|
QPolygonF mapToScene(QGraphicsView* theWrappedObject, const QPolygon& polygon) const;
|
|
|
QPolygonF mapToScene(QGraphicsView* theWrappedObject, const QRect& rect) const;
|
|
|
QPointF mapToScene(QGraphicsView* theWrappedObject, int x, int y) const;
|
|
|
QPolygonF mapToScene(QGraphicsView* theWrappedObject, int x, int y, int w, int h) const;
|
|
|
QMatrix matrix(QGraphicsView* theWrappedObject) const;
|
|
|
void mouseDoubleClickEvent(QGraphicsView* theWrappedObject, QMouseEvent* event);
|
|
|
void mouseMoveEvent(QGraphicsView* theWrappedObject, QMouseEvent* event);
|
|
|
void mousePressEvent(QGraphicsView* theWrappedObject, QMouseEvent* event);
|
|
|
void mouseReleaseEvent(QGraphicsView* theWrappedObject, QMouseEvent* event);
|
|
|
QGraphicsView::OptimizationFlags optimizationFlags(QGraphicsView* theWrappedObject) const;
|
|
|
void paintEvent(QGraphicsView* theWrappedObject, QPaintEvent* event);
|
|
|
void render(QGraphicsView* theWrappedObject, QPainter* painter, const QRectF& target = QRectF(), const QRect& source = QRect(), Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio);
|
|
|
QPainter::RenderHints renderHints(QGraphicsView* theWrappedObject) const;
|
|
|
void resetCachedContent(QGraphicsView* theWrappedObject);
|
|
|
void resetMatrix(QGraphicsView* theWrappedObject);
|
|
|
void resetTransform(QGraphicsView* theWrappedObject);
|
|
|
QGraphicsView::ViewportAnchor resizeAnchor(QGraphicsView* theWrappedObject) const;
|
|
|
void resizeEvent(QGraphicsView* theWrappedObject, QResizeEvent* event);
|
|
|
void rotate(QGraphicsView* theWrappedObject, qreal angle);
|
|
|
Qt::ItemSelectionMode rubberBandSelectionMode(QGraphicsView* theWrappedObject) const;
|
|
|
void scale(QGraphicsView* theWrappedObject, qreal sx, qreal sy);
|
|
|
QGraphicsScene* scene(QGraphicsView* theWrappedObject) const;
|
|
|
QRectF sceneRect(QGraphicsView* theWrappedObject) const;
|
|
|
void scrollContentsBy(QGraphicsView* theWrappedObject, int dx, int dy);
|
|
|
void setAlignment(QGraphicsView* theWrappedObject, Qt::Alignment alignment);
|
|
|
void setBackgroundBrush(QGraphicsView* theWrappedObject, const QBrush& brush);
|
|
|
void setCacheMode(QGraphicsView* theWrappedObject, QGraphicsView::CacheMode mode);
|
|
|
void setDragMode(QGraphicsView* theWrappedObject, QGraphicsView::DragMode mode);
|
|
|
void setForegroundBrush(QGraphicsView* theWrappedObject, const QBrush& brush);
|
|
|
void setInteractive(QGraphicsView* theWrappedObject, bool allowed);
|
|
|
void setMatrix(QGraphicsView* theWrappedObject, const QMatrix& matrix, bool combine = false);
|
|
|
void setOptimizationFlag(QGraphicsView* theWrappedObject, QGraphicsView::OptimizationFlag flag, bool enabled = true);
|
|
|
void setOptimizationFlags(QGraphicsView* theWrappedObject, QGraphicsView::OptimizationFlags flags);
|
|
|
void setRenderHint(QGraphicsView* theWrappedObject, QPainter::RenderHint hint, bool enabled = true);
|
|
|
void setRenderHints(QGraphicsView* theWrappedObject, QPainter::RenderHints hints);
|
|
|
void setResizeAnchor(QGraphicsView* theWrappedObject, QGraphicsView::ViewportAnchor anchor);
|
|
|
void setRubberBandSelectionMode(QGraphicsView* theWrappedObject, Qt::ItemSelectionMode mode);
|
|
|
void setScene(QGraphicsView* theWrappedObject, QGraphicsScene* scene);
|
|
|
void setSceneRect(QGraphicsView* theWrappedObject, const QRectF& rect);
|
|
|
void setSceneRect(QGraphicsView* theWrappedObject, qreal x, qreal y, qreal w, qreal h);
|
|
|
void setTransform(QGraphicsView* theWrappedObject, const QTransform& matrix, bool combine = false);
|
|
|
void setTransformationAnchor(QGraphicsView* theWrappedObject, QGraphicsView::ViewportAnchor anchor);
|
|
|
void setViewportUpdateMode(QGraphicsView* theWrappedObject, QGraphicsView::ViewportUpdateMode mode);
|
|
|
void setupViewport(QGraphicsView* theWrappedObject, QWidget* widget);
|
|
|
void shear(QGraphicsView* theWrappedObject, qreal sh, qreal sv);
|
|
|
void showEvent(QGraphicsView* theWrappedObject, QShowEvent* event);
|
|
|
QSize sizeHint(QGraphicsView* theWrappedObject) const;
|
|
|
QTransform transform(QGraphicsView* theWrappedObject) const;
|
|
|
QGraphicsView::ViewportAnchor transformationAnchor(QGraphicsView* theWrappedObject) const;
|
|
|
void translate(QGraphicsView* theWrappedObject, qreal dx, qreal dy);
|
|
|
bool viewportEvent(QGraphicsView* theWrappedObject, QEvent* event);
|
|
|
QTransform viewportTransform(QGraphicsView* theWrappedObject) const;
|
|
|
QGraphicsView::ViewportUpdateMode viewportUpdateMode(QGraphicsView* theWrappedObject) const;
|
|
|
void wheelEvent(QGraphicsView* theWrappedObject, QWheelEvent* event);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGraphicsWidget : public QGraphicsWidget
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGraphicsWidget(QGraphicsItem* parent = 0, Qt::WindowFlags wFlags = 0):QGraphicsWidget(parent, wFlags),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGraphicsWidget();
|
|
|
|
|
|
virtual void changeEvent(QEvent* event);
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void closeEvent(QCloseEvent* event);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* event);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual bool focusNextPrevChild(bool next);
|
|
|
virtual void getContentsMargins(qreal* left, qreal* top, qreal* right, qreal* bottom) const;
|
|
|
virtual void grabKeyboardEvent(QEvent* event);
|
|
|
virtual void grabMouseEvent(QEvent* event);
|
|
|
virtual void hideEvent(QHideEvent* event);
|
|
|
virtual void hoverLeaveEvent(QGraphicsSceneHoverEvent* event);
|
|
|
virtual void hoverMoveEvent(QGraphicsSceneHoverEvent* event);
|
|
|
virtual void initStyleOption(QStyleOption* option) const;
|
|
|
virtual void moveEvent(QGraphicsSceneMoveEvent* event);
|
|
|
virtual void paintWindowFrame(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0);
|
|
|
virtual void polishEvent();
|
|
|
virtual QVariant propertyChange(const QString& propertyName, const QVariant& value);
|
|
|
virtual void resizeEvent(QGraphicsSceneResizeEvent* event);
|
|
|
virtual void setGeometry(const QRectF& rect);
|
|
|
virtual void showEvent(QShowEvent* event);
|
|
|
virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint = QSizeF()) const;
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
virtual void ungrabKeyboardEvent(QEvent* event);
|
|
|
virtual void ungrabMouseEvent(QEvent* event);
|
|
|
virtual void updateGeometry();
|
|
|
virtual bool windowFrameEvent(QEvent* e);
|
|
|
virtual Qt::WindowFrameSection windowFrameSectionAt(const QPointF& pos) const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QGraphicsWidget : public QGraphicsWidget
|
|
|
{ public:
|
|
|
inline void promoted_changeEvent(QEvent* event) { QGraphicsWidget::changeEvent(event); }
|
|
|
inline void promoted_closeEvent(QCloseEvent* event) { QGraphicsWidget::closeEvent(event); }
|
|
|
inline bool promoted_event(QEvent* event) { return QGraphicsWidget::event(event); }
|
|
|
inline bool promoted_focusNextPrevChild(bool next) { return QGraphicsWidget::focusNextPrevChild(next); }
|
|
|
inline void promoted_getContentsMargins(qreal* left, qreal* top, qreal* right, qreal* bottom) const { QGraphicsWidget::getContentsMargins(left, top, right, bottom); }
|
|
|
inline void promoted_grabKeyboardEvent(QEvent* event) { QGraphicsWidget::grabKeyboardEvent(event); }
|
|
|
inline void promoted_grabMouseEvent(QEvent* event) { QGraphicsWidget::grabMouseEvent(event); }
|
|
|
inline void promoted_hideEvent(QHideEvent* event) { QGraphicsWidget::hideEvent(event); }
|
|
|
inline void promoted_hoverLeaveEvent(QGraphicsSceneHoverEvent* event) { QGraphicsWidget::hoverLeaveEvent(event); }
|
|
|
inline void promoted_hoverMoveEvent(QGraphicsSceneHoverEvent* event) { QGraphicsWidget::hoverMoveEvent(event); }
|
|
|
inline void promoted_initStyleOption(QStyleOption* option) const { QGraphicsWidget::initStyleOption(option); }
|
|
|
inline void promoted_moveEvent(QGraphicsSceneMoveEvent* event) { QGraphicsWidget::moveEvent(event); }
|
|
|
inline void promoted_paintWindowFrame(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0) { QGraphicsWidget::paintWindowFrame(painter, option, widget); }
|
|
|
inline void promoted_polishEvent() { QGraphicsWidget::polishEvent(); }
|
|
|
inline QVariant promoted_propertyChange(const QString& propertyName, const QVariant& value) { return QGraphicsWidget::propertyChange(propertyName, value); }
|
|
|
inline void promoted_resizeEvent(QGraphicsSceneResizeEvent* event) { QGraphicsWidget::resizeEvent(event); }
|
|
|
inline void promoted_setGeometry(const QRectF& rect) { QGraphicsWidget::setGeometry(rect); }
|
|
|
inline void promoted_showEvent(QShowEvent* event) { QGraphicsWidget::showEvent(event); }
|
|
|
inline QSizeF promoted_sizeHint(Qt::SizeHint which, const QSizeF& constraint = QSizeF()) const { return QGraphicsWidget::sizeHint(which, constraint); }
|
|
|
inline void promoted_ungrabKeyboardEvent(QEvent* event) { QGraphicsWidget::ungrabKeyboardEvent(event); }
|
|
|
inline void promoted_ungrabMouseEvent(QEvent* event) { QGraphicsWidget::ungrabMouseEvent(event); }
|
|
|
inline void promoted_updateGeometry() { QGraphicsWidget::updateGeometry(); }
|
|
|
inline bool promoted_windowFrameEvent(QEvent* e) { return QGraphicsWidget::windowFrameEvent(e); }
|
|
|
inline Qt::WindowFrameSection promoted_windowFrameSectionAt(const QPointF& pos) const { return QGraphicsWidget::windowFrameSectionAt(pos); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGraphicsWidget : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(enum_1 )
|
|
|
enum enum_1{
|
|
|
Type = QGraphicsWidget::Type};
|
|
|
public slots:
|
|
|
QGraphicsWidget* new_QGraphicsWidget(QGraphicsItem* parent = 0, Qt::WindowFlags wFlags = 0);
|
|
|
void delete_QGraphicsWidget(QGraphicsWidget* obj) { delete obj; }
|
|
|
QList<QAction* > actions(QGraphicsWidget* theWrappedObject) const;
|
|
|
void addAction(QGraphicsWidget* theWrappedObject, QAction* action);
|
|
|
void addActions(QGraphicsWidget* theWrappedObject, QList<QAction* > actions);
|
|
|
void adjustSize(QGraphicsWidget* theWrappedObject);
|
|
|
bool autoFillBackground(QGraphicsWidget* theWrappedObject) const;
|
|
|
QRectF boundingRect(QGraphicsWidget* theWrappedObject) const;
|
|
|
void changeEvent(QGraphicsWidget* theWrappedObject, QEvent* event);
|
|
|
void closeEvent(QGraphicsWidget* theWrappedObject, QCloseEvent* event);
|
|
|
bool event(QGraphicsWidget* theWrappedObject, QEvent* event);
|
|
|
bool focusNextPrevChild(QGraphicsWidget* theWrappedObject, bool next);
|
|
|
Qt::FocusPolicy focusPolicy(QGraphicsWidget* theWrappedObject) const;
|
|
|
QGraphicsWidget* focusWidget(QGraphicsWidget* theWrappedObject) const;
|
|
|
QFont font(QGraphicsWidget* theWrappedObject) const;
|
|
|
void getContentsMargins(QGraphicsWidget* theWrappedObject, qreal* left, qreal* top, qreal* right, qreal* bottom) const;
|
|
|
void getWindowFrameMargins(QGraphicsWidget* theWrappedObject, qreal* left, qreal* top, qreal* right, qreal* bottom) const;
|
|
|
void grabKeyboardEvent(QGraphicsWidget* theWrappedObject, QEvent* event);
|
|
|
void grabMouseEvent(QGraphicsWidget* theWrappedObject, QEvent* event);
|
|
|
int grabShortcut(QGraphicsWidget* theWrappedObject, const QKeySequence& sequence, Qt::ShortcutContext context = Qt::WindowShortcut);
|
|
|
void hideEvent(QGraphicsWidget* theWrappedObject, QHideEvent* event);
|
|
|
void hoverLeaveEvent(QGraphicsWidget* theWrappedObject, QGraphicsSceneHoverEvent* event);
|
|
|
void hoverMoveEvent(QGraphicsWidget* theWrappedObject, QGraphicsSceneHoverEvent* event);
|
|
|
void initStyleOption(QGraphicsWidget* theWrappedObject, QStyleOption* option) const;
|
|
|
void insertAction(QGraphicsWidget* theWrappedObject, QAction* before, QAction* action);
|
|
|
void insertActions(QGraphicsWidget* theWrappedObject, QAction* before, QList<QAction* > actions);
|
|
|
bool isActiveWindow(QGraphicsWidget* theWrappedObject) const;
|
|
|
QGraphicsLayout* layout(QGraphicsWidget* theWrappedObject) const;
|
|
|
Qt::LayoutDirection layoutDirection(QGraphicsWidget* theWrappedObject) const;
|
|
|
void moveEvent(QGraphicsWidget* theWrappedObject, QGraphicsSceneMoveEvent* event);
|
|
|
void paint(QGraphicsWidget* theWrappedObject, QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0);
|
|
|
void paintWindowFrame(QGraphicsWidget* theWrappedObject, QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0);
|
|
|
QPalette palette(QGraphicsWidget* theWrappedObject) const;
|
|
|
void polishEvent(QGraphicsWidget* theWrappedObject);
|
|
|
QVariant propertyChange(QGraphicsWidget* theWrappedObject, const QString& propertyName, const QVariant& value);
|
|
|
QRectF rect(QGraphicsWidget* theWrappedObject) const;
|
|
|
void releaseShortcut(QGraphicsWidget* theWrappedObject, int id);
|
|
|
void removeAction(QGraphicsWidget* theWrappedObject, QAction* action);
|
|
|
void resize(QGraphicsWidget* theWrappedObject, const QSizeF& size);
|
|
|
void resize(QGraphicsWidget* theWrappedObject, qreal w, qreal h);
|
|
|
void resizeEvent(QGraphicsWidget* theWrappedObject, QGraphicsSceneResizeEvent* event);
|
|
|
void setAttribute(QGraphicsWidget* theWrappedObject, Qt::WidgetAttribute attribute, bool on = true);
|
|
|
void setAutoFillBackground(QGraphicsWidget* theWrappedObject, bool enabled);
|
|
|
void setContentsMargins(QGraphicsWidget* theWrappedObject, qreal left, qreal top, qreal right, qreal bottom);
|
|
|
void setFocusPolicy(QGraphicsWidget* theWrappedObject, Qt::FocusPolicy policy);
|
|
|
void setFont(QGraphicsWidget* theWrappedObject, const QFont& font);
|
|
|
void setGeometry(QGraphicsWidget* theWrappedObject, const QRectF& rect);
|
|
|
void setGeometry(QGraphicsWidget* theWrappedObject, qreal x, qreal y, qreal w, qreal h);
|
|
|
void setLayout(QGraphicsWidget* theWrappedObject, QGraphicsLayout* layout);
|
|
|
void setLayoutDirection(QGraphicsWidget* theWrappedObject, Qt::LayoutDirection direction);
|
|
|
void setPalette(QGraphicsWidget* theWrappedObject, const QPalette& palette);
|
|
|
void setShortcutAutoRepeat(QGraphicsWidget* theWrappedObject, int id, bool enabled = true);
|
|
|
void setShortcutEnabled(QGraphicsWidget* theWrappedObject, int id, bool enabled = true);
|
|
|
void setStyle(QGraphicsWidget* theWrappedObject, QStyle* style);
|
|
|
void static_QGraphicsWidget_setTabOrder(QGraphicsWidget* first, QGraphicsWidget* second);
|
|
|
void setWindowFlags(QGraphicsWidget* theWrappedObject, Qt::WindowFlags wFlags);
|
|
|
void setWindowFrameMargins(QGraphicsWidget* theWrappedObject, qreal left, qreal top, qreal right, qreal bottom);
|
|
|
void setWindowTitle(QGraphicsWidget* theWrappedObject, const QString& title);
|
|
|
QPainterPath shape(QGraphicsWidget* theWrappedObject) const;
|
|
|
void showEvent(QGraphicsWidget* theWrappedObject, QShowEvent* event);
|
|
|
QSizeF size(QGraphicsWidget* theWrappedObject) const;
|
|
|
QSizeF sizeHint(QGraphicsWidget* theWrappedObject, Qt::SizeHint which, const QSizeF& constraint = QSizeF()) const;
|
|
|
QStyle* style(QGraphicsWidget* theWrappedObject) const;
|
|
|
bool testAttribute(QGraphicsWidget* theWrappedObject, Qt::WidgetAttribute attribute) const;
|
|
|
int type(QGraphicsWidget* theWrappedObject) const;
|
|
|
void ungrabKeyboardEvent(QGraphicsWidget* theWrappedObject, QEvent* event);
|
|
|
void ungrabMouseEvent(QGraphicsWidget* theWrappedObject, QEvent* event);
|
|
|
void unsetLayoutDirection(QGraphicsWidget* theWrappedObject);
|
|
|
void unsetWindowFrameMargins(QGraphicsWidget* theWrappedObject);
|
|
|
void updateGeometry(QGraphicsWidget* theWrappedObject);
|
|
|
Qt::WindowFlags windowFlags(QGraphicsWidget* theWrappedObject) const;
|
|
|
bool windowFrameEvent(QGraphicsWidget* theWrappedObject, QEvent* e);
|
|
|
QRectF windowFrameGeometry(QGraphicsWidget* theWrappedObject) const;
|
|
|
QRectF windowFrameRect(QGraphicsWidget* theWrappedObject) const;
|
|
|
Qt::WindowFrameSection windowFrameSectionAt(QGraphicsWidget* theWrappedObject, const QPointF& pos) const;
|
|
|
QString windowTitle(QGraphicsWidget* theWrappedObject) const;
|
|
|
Qt::WindowType windowType(QGraphicsWidget* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGridLayout : public QGridLayout
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGridLayout():QGridLayout(),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGridLayout(QWidget* parent):QGridLayout(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGridLayout();
|
|
|
|
|
|
virtual void addItem(QLayoutItem* arg__1);
|
|
|
virtual void childEvent(QChildEvent* e);
|
|
|
virtual QSizePolicy::ControlTypes controlTypes() const;
|
|
|
virtual int count() const;
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual Qt::Orientations expandingDirections() const;
|
|
|
virtual QRect geometry() const;
|
|
|
virtual int indexOf(QWidget* arg__1) const;
|
|
|
virtual void invalidate();
|
|
|
virtual bool isEmpty() const;
|
|
|
virtual QLayoutItem* itemAt(int index) const;
|
|
|
virtual QLayout* layout();
|
|
|
virtual QSize maximumSize() const;
|
|
|
virtual QSize minimumSize() const;
|
|
|
virtual void setGeometry(const QRect& arg__1);
|
|
|
virtual QLayoutItem* takeAt(int index);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QGridLayout : public QGridLayout
|
|
|
{ public:
|
|
|
inline void promoted_addItem(QLayoutItem* arg__1) { QGridLayout::addItem(arg__1); }
|
|
|
inline int promoted_count() const { return QGridLayout::count(); }
|
|
|
inline Qt::Orientations promoted_expandingDirections() const { return QGridLayout::expandingDirections(); }
|
|
|
inline void promoted_invalidate() { QGridLayout::invalidate(); }
|
|
|
inline QLayoutItem* promoted_itemAt(int index) const { return QGridLayout::itemAt(index); }
|
|
|
inline QSize promoted_maximumSize() const { return QGridLayout::maximumSize(); }
|
|
|
inline QSize promoted_minimumSize() const { return QGridLayout::minimumSize(); }
|
|
|
inline void promoted_setGeometry(const QRect& arg__1) { QGridLayout::setGeometry(arg__1); }
|
|
|
inline QLayoutItem* promoted_takeAt(int index) { return QGridLayout::takeAt(index); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGridLayout : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QGridLayout* new_QGridLayout();
|
|
|
QGridLayout* new_QGridLayout(QWidget* parent);
|
|
|
void delete_QGridLayout(QGridLayout* obj) { delete obj; }
|
|
|
void addItem(QGridLayout* theWrappedObject, QLayoutItem* arg__1);
|
|
|
void addItem(QGridLayout* theWrappedObject, QLayoutItem* item, int row, int column, int rowSpan = 1, int columnSpan = 1, Qt::Alignment arg__6 = 0);
|
|
|
void addLayout(QGridLayout* theWrappedObject, QLayout* arg__1, int row, int column, Qt::Alignment arg__4 = 0);
|
|
|
void addLayout(QGridLayout* theWrappedObject, QLayout* arg__1, int row, int column, int rowSpan, int columnSpan, Qt::Alignment arg__6 = 0);
|
|
|
void addWidget(QGridLayout* theWrappedObject, QWidget* arg__1, int row, int column, Qt::Alignment arg__4 = 0);
|
|
|
void addWidget(QGridLayout* theWrappedObject, QWidget* arg__1, int row, int column, int rowSpan, int columnSpan, Qt::Alignment arg__6 = 0);
|
|
|
QRect cellRect(QGridLayout* theWrappedObject, int row, int column) const;
|
|
|
int columnCount(QGridLayout* theWrappedObject) const;
|
|
|
int columnMinimumWidth(QGridLayout* theWrappedObject, int column) const;
|
|
|
int columnStretch(QGridLayout* theWrappedObject, int column) const;
|
|
|
int count(QGridLayout* theWrappedObject) const;
|
|
|
Qt::Orientations expandingDirections(QGridLayout* theWrappedObject) const;
|
|
|
void getItemPosition(QGridLayout* theWrappedObject, int idx, int* row, int* column, int* rowSpan, int* columnSpan) const;
|
|
|
bool hasHeightForWidth(QGridLayout* theWrappedObject) const;
|
|
|
int heightForWidth(QGridLayout* theWrappedObject, int arg__1) const;
|
|
|
int horizontalSpacing(QGridLayout* theWrappedObject) const;
|
|
|
void invalidate(QGridLayout* theWrappedObject);
|
|
|
QLayoutItem* itemAt(QGridLayout* theWrappedObject, int index) const;
|
|
|
QLayoutItem* itemAtPosition(QGridLayout* theWrappedObject, int row, int column) const;
|
|
|
QSize maximumSize(QGridLayout* theWrappedObject) const;
|
|
|
int minimumHeightForWidth(QGridLayout* theWrappedObject, int arg__1) const;
|
|
|
QSize minimumSize(QGridLayout* theWrappedObject) const;
|
|
|
Qt::Corner originCorner(QGridLayout* theWrappedObject) const;
|
|
|
int rowCount(QGridLayout* theWrappedObject) const;
|
|
|
int rowMinimumHeight(QGridLayout* theWrappedObject, int row) const;
|
|
|
int rowStretch(QGridLayout* theWrappedObject, int row) const;
|
|
|
void setColumnMinimumWidth(QGridLayout* theWrappedObject, int column, int minSize);
|
|
|
void setColumnStretch(QGridLayout* theWrappedObject, int column, int stretch);
|
|
|
void setDefaultPositioning(QGridLayout* theWrappedObject, int n, Qt::Orientation orient);
|
|
|
void setGeometry(QGridLayout* theWrappedObject, const QRect& arg__1);
|
|
|
void setHorizontalSpacing(QGridLayout* theWrappedObject, int spacing);
|
|
|
void setOriginCorner(QGridLayout* theWrappedObject, Qt::Corner arg__1);
|
|
|
void setRowMinimumHeight(QGridLayout* theWrappedObject, int row, int minSize);
|
|
|
void setRowStretch(QGridLayout* theWrappedObject, int row, int stretch);
|
|
|
void setSpacing(QGridLayout* theWrappedObject, int spacing);
|
|
|
void setVerticalSpacing(QGridLayout* theWrappedObject, int spacing);
|
|
|
QSize sizeHint(QGridLayout* theWrappedObject) const;
|
|
|
int spacing(QGridLayout* theWrappedObject) const;
|
|
|
QLayoutItem* takeAt(QGridLayout* theWrappedObject, int index);
|
|
|
int verticalSpacing(QGridLayout* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGroupBox : public QGroupBox
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGroupBox(QWidget* parent = 0):QGroupBox(parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QGroupBox(const QString& title, QWidget* parent = 0):QGroupBox(title, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGroupBox();
|
|
|
|
|
|
virtual void actionEvent(QActionEvent* arg__1);
|
|
|
virtual void changeEvent(QEvent* event);
|
|
|
virtual void childEvent(QChildEvent* event);
|
|
|
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* event);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void focusInEvent(QFocusEvent* event);
|
|
|
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 void mouseDoubleClickEvent(QMouseEvent* arg__1);
|
|
|
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* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QGroupBox : public QGroupBox
|
|
|
{ public:
|
|
|
inline void promoted_changeEvent(QEvent* event) { QGroupBox::changeEvent(event); }
|
|
|
inline void promoted_childEvent(QChildEvent* event) { QGroupBox::childEvent(event); }
|
|
|
inline bool promoted_event(QEvent* event) { return QGroupBox::event(event); }
|
|
|
inline void promoted_focusInEvent(QFocusEvent* event) { QGroupBox::focusInEvent(event); }
|
|
|
inline void promoted_mouseMoveEvent(QMouseEvent* event) { QGroupBox::mouseMoveEvent(event); }
|
|
|
inline void promoted_mousePressEvent(QMouseEvent* event) { QGroupBox::mousePressEvent(event); }
|
|
|
inline void promoted_mouseReleaseEvent(QMouseEvent* event) { QGroupBox::mouseReleaseEvent(event); }
|
|
|
inline void promoted_paintEvent(QPaintEvent* event) { QGroupBox::paintEvent(event); }
|
|
|
inline void promoted_resizeEvent(QResizeEvent* event) { QGroupBox::resizeEvent(event); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGroupBox : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QGroupBox* new_QGroupBox(QWidget* parent = 0);
|
|
|
QGroupBox* new_QGroupBox(const QString& title, QWidget* parent = 0);
|
|
|
void delete_QGroupBox(QGroupBox* obj) { delete obj; }
|
|
|
Qt::Alignment alignment(QGroupBox* theWrappedObject) const;
|
|
|
void changeEvent(QGroupBox* theWrappedObject, QEvent* event);
|
|
|
void childEvent(QGroupBox* theWrappedObject, QChildEvent* event);
|
|
|
bool event(QGroupBox* theWrappedObject, QEvent* event);
|
|
|
void focusInEvent(QGroupBox* theWrappedObject, QFocusEvent* event);
|
|
|
bool isCheckable(QGroupBox* theWrappedObject) const;
|
|
|
bool isChecked(QGroupBox* theWrappedObject) const;
|
|
|
bool isFlat(QGroupBox* theWrappedObject) const;
|
|
|
QSize minimumSizeHint(QGroupBox* theWrappedObject) const;
|
|
|
void mouseMoveEvent(QGroupBox* theWrappedObject, QMouseEvent* event);
|
|
|
void mousePressEvent(QGroupBox* theWrappedObject, QMouseEvent* event);
|
|
|
void mouseReleaseEvent(QGroupBox* theWrappedObject, QMouseEvent* event);
|
|
|
void paintEvent(QGroupBox* theWrappedObject, QPaintEvent* event);
|
|
|
void resizeEvent(QGroupBox* theWrappedObject, QResizeEvent* event);
|
|
|
void setAlignment(QGroupBox* theWrappedObject, int alignment);
|
|
|
void setCheckable(QGroupBox* theWrappedObject, bool checkable);
|
|
|
void setFlat(QGroupBox* theWrappedObject, bool flat);
|
|
|
void setTitle(QGroupBox* theWrappedObject, const QString& title);
|
|
|
QString title(QGroupBox* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QGuiApplication : public QGuiApplication
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QGuiApplication(int& argc, char** argv, int arg__3 = ApplicationFlags):QGuiApplication(argc, argv, arg__3),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QGuiApplication();
|
|
|
|
|
|
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 bool notify(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QGuiApplication : public QGuiApplication
|
|
|
{ public:
|
|
|
inline bool promoted_event(QEvent* arg__1) { return QGuiApplication::event(arg__1); }
|
|
|
inline bool promoted_notify(QObject* arg__1, QEvent* arg__2) { return QGuiApplication::notify(arg__1, arg__2); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QGuiApplication : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QGuiApplication* new_QGuiApplication(int& argc, char** argv);
|
|
|
void delete_QGuiApplication(QGuiApplication* obj) { delete obj; }
|
|
|
QString static_QGuiApplication_applicationDisplayName();
|
|
|
void static_QGuiApplication_changeOverrideCursor(const QCursor& arg__1);
|
|
|
QClipboard* static_QGuiApplication_clipboard();
|
|
|
bool static_QGuiApplication_desktopSettingsAware();
|
|
|
qreal devicePixelRatio(QGuiApplication* theWrappedObject) const;
|
|
|
bool event(QGuiApplication* theWrappedObject, QEvent* arg__1);
|
|
|
int static_QGuiApplication_exec();
|
|
|
QObject* static_QGuiApplication_focusObject();
|
|
|
QFont static_QGuiApplication_font();
|
|
|
bool static_QGuiApplication_isLeftToRight();
|
|
|
bool static_QGuiApplication_isRightToLeft();
|
|
|
bool isSavingSession(QGuiApplication* theWrappedObject) const;
|
|
|
bool isSessionRestored(QGuiApplication* theWrappedObject) const;
|
|
|
Qt::KeyboardModifiers static_QGuiApplication_keyboardModifiers();
|
|
|
Qt::LayoutDirection static_QGuiApplication_layoutDirection();
|
|
|
Qt::MouseButtons static_QGuiApplication_mouseButtons();
|
|
|
bool notify(QGuiApplication* theWrappedObject, QObject* arg__1, QEvent* arg__2);
|
|
|
QCursor* static_QGuiApplication_overrideCursor();
|
|
|
QPalette static_QGuiApplication_palette();
|
|
|
QString static_QGuiApplication_platformName();
|
|
|
Qt::KeyboardModifiers static_QGuiApplication_queryKeyboardModifiers();
|
|
|
bool static_QGuiApplication_quitOnLastWindowClosed();
|
|
|
void static_QGuiApplication_restoreOverrideCursor();
|
|
|
QString sessionId(QGuiApplication* theWrappedObject) const;
|
|
|
QString sessionKey(QGuiApplication* theWrappedObject) const;
|
|
|
void static_QGuiApplication_setApplicationDisplayName(const QString& name);
|
|
|
void static_QGuiApplication_setDesktopSettingsAware(bool on);
|
|
|
void static_QGuiApplication_setFont(const QFont& arg__1);
|
|
|
void static_QGuiApplication_setLayoutDirection(Qt::LayoutDirection direction);
|
|
|
void static_QGuiApplication_setOverrideCursor(const QCursor& arg__1);
|
|
|
void static_QGuiApplication_setPalette(const QPalette& pal);
|
|
|
void static_QGuiApplication_setQuitOnLastWindowClosed(bool quit);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QHBoxLayout : public QHBoxLayout
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QHBoxLayout():QHBoxLayout(),_wrapper(NULL) {};
|
|
|
PythonQtShell_QHBoxLayout(QWidget* parent):QHBoxLayout(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QHBoxLayout();
|
|
|
|
|
|
virtual void addItem(QLayoutItem* arg__1);
|
|
|
virtual void childEvent(QChildEvent* e);
|
|
|
virtual QSizePolicy::ControlTypes controlTypes() const;
|
|
|
virtual int count() const;
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual Qt::Orientations expandingDirections() const;
|
|
|
virtual QRect geometry() const;
|
|
|
virtual int indexOf(QWidget* arg__1) const;
|
|
|
virtual void invalidate();
|
|
|
virtual bool isEmpty() const;
|
|
|
virtual QLayoutItem* itemAt(int arg__1) const;
|
|
|
virtual QLayout* layout();
|
|
|
virtual QSize maximumSize() const;
|
|
|
virtual QSize minimumSize() const;
|
|
|
virtual void setGeometry(const QRect& arg__1);
|
|
|
virtual QLayoutItem* takeAt(int arg__1);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QHBoxLayout : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QHBoxLayout* new_QHBoxLayout();
|
|
|
QHBoxLayout* new_QHBoxLayout(QWidget* parent);
|
|
|
void delete_QHBoxLayout(QHBoxLayout* obj) { delete obj; }
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QHeaderView : public QHeaderView
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QHeaderView(Qt::Orientation orientation, QWidget* parent = 0):QHeaderView(orientation, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QHeaderView();
|
|
|
|
|
|
virtual void actionEvent(QActionEvent* arg__1);
|
|
|
virtual void changeEvent(QEvent* arg__1);
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void closeEditor(QWidget* editor, QAbstractItemDelegate::EndEditHint hint);
|
|
|
virtual void closeEvent(QCloseEvent* arg__1);
|
|
|
virtual void commitData(QWidget* editor);
|
|
|
virtual void contextMenuEvent(QContextMenuEvent* arg__1);
|
|
|
virtual void currentChanged(const QModelIndex& current, const QModelIndex& old);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual void dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int >& roles = QVector<int>());
|
|
|
virtual int devType() const;
|
|
|
virtual void doItemsLayout();
|
|
|
virtual void dragEnterEvent(QDragEnterEvent* event);
|
|
|
virtual void dragLeaveEvent(QDragLeaveEvent* event);
|
|
|
virtual void dragMoveEvent(QDragMoveEvent* event);
|
|
|
virtual void dropEvent(QDropEvent* event);
|
|
|
virtual bool edit(const QModelIndex& index, QAbstractItemView::EditTrigger trigger, QEvent* event);
|
|
|
virtual void editorDestroyed(QObject* editor);
|
|
|
virtual void enterEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* e);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void focusInEvent(QFocusEvent* event);
|
|
|
virtual bool focusNextPrevChild(bool next);
|
|
|
virtual void focusOutEvent(QFocusEvent* event);
|
|
|
virtual bool hasHeightForWidth() const;
|
|
|
virtual int heightForWidth(int arg__1) const;
|
|
|
virtual void hideEvent(QHideEvent* arg__1);
|
|
|
virtual int horizontalOffset() const;
|
|
|
virtual void horizontalScrollbarAction(int action);
|
|
|
virtual void horizontalScrollbarValueChanged(int value);
|
|
|
virtual QModelIndex indexAt(const QPoint& p) const;
|
|
|
virtual void initPainter(QPainter* painter) const;
|
|
|
virtual void inputMethodEvent(QInputMethodEvent* event);
|
|
|
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
|
|
|
virtual bool isIndexHidden(const QModelIndex& index) const;
|
|
|
virtual void keyPressEvent(QKeyEvent* event);
|
|
|
virtual void keyReleaseEvent(QKeyEvent* arg__1);
|
|
|
virtual void keyboardSearch(const QString& search);
|
|
|
virtual void leaveEvent(QEvent* arg__1);
|
|
|
virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
|
|
|
virtual void mouseDoubleClickEvent(QMouseEvent* e);
|
|
|
virtual void mouseMoveEvent(QMouseEvent* e);
|
|
|
virtual void mousePressEvent(QMouseEvent* e);
|
|
|
virtual void mouseReleaseEvent(QMouseEvent* e);
|
|
|
virtual void moveEvent(QMoveEvent* arg__1);
|
|
|
virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
|
|
|
virtual QPaintEngine* paintEngine() const;
|
|
|
virtual void paintEvent(QPaintEvent* e);
|
|
|
virtual void paintSection(QPainter* painter, const QRect& rect, int logicalIndex) const;
|
|
|
virtual QPaintDevice* redirected(QPoint* offset) const;
|
|
|
virtual void reset();
|
|
|
virtual void resizeEvent(QResizeEvent* event);
|
|
|
virtual void rowsAboutToBeRemoved(const QModelIndex& parent, int start, int end);
|
|
|
virtual void rowsInserted(const QModelIndex& parent, int start, int end);
|
|
|
virtual void scrollContentsBy(int dx, int dy);
|
|
|
virtual void scrollTo(const QModelIndex& index, QAbstractItemView::ScrollHint hint);
|
|
|
virtual QSize sectionSizeFromContents(int logicalIndex) const;
|
|
|
virtual void selectAll();
|
|
|
virtual QList<QModelIndex > selectedIndexes() const;
|
|
|
virtual void selectionChanged(const QItemSelection& selected, const QItemSelection& deselected);
|
|
|
virtual QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex& index, const QEvent* event) const;
|
|
|
virtual void setModel(QAbstractItemModel* model);
|
|
|
virtual void setRootIndex(const QModelIndex& index);
|
|
|
virtual void setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags flags);
|
|
|
virtual void setSelectionModel(QItemSelectionModel* selectionModel);
|
|
|
virtual void setupViewport(QWidget* viewport);
|
|
|
virtual QPainter* sharedPainter() const;
|
|
|
virtual void showEvent(QShowEvent* arg__1);
|
|
|
virtual int sizeHintForColumn(int column) const;
|
|
|
virtual int sizeHintForRow(int row) const;
|
|
|
virtual void startDrag(Qt::DropActions supportedActions);
|
|
|
virtual void tabletEvent(QTabletEvent* arg__1);
|
|
|
virtual void timerEvent(QTimerEvent* event);
|
|
|
virtual void updateEditorData();
|
|
|
virtual void updateEditorGeometries();
|
|
|
virtual void updateGeometries();
|
|
|
virtual int verticalOffset() const;
|
|
|
virtual void verticalScrollbarAction(int action);
|
|
|
virtual void verticalScrollbarValueChanged(int value);
|
|
|
virtual QStyleOptionViewItem viewOptions() const;
|
|
|
virtual bool viewportEvent(QEvent* e);
|
|
|
virtual QSize viewportSizeHint() const;
|
|
|
virtual QRect visualRect(const QModelIndex& index) const;
|
|
|
virtual QRegion visualRegionForSelection(const QItemSelection& selection) const;
|
|
|
virtual void wheelEvent(QWheelEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QHeaderView : public QHeaderView
|
|
|
{ public:
|
|
|
inline void promoted_currentChanged(const QModelIndex& current, const QModelIndex& old) { QHeaderView::currentChanged(current, old); }
|
|
|
inline void promoted_dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int >& roles = QVector<int>()) { QHeaderView::dataChanged(topLeft, bottomRight, roles); }
|
|
|
inline void promoted_doItemsLayout() { QHeaderView::doItemsLayout(); }
|
|
|
inline bool promoted_event(QEvent* e) { return QHeaderView::event(e); }
|
|
|
inline int promoted_horizontalOffset() const { return QHeaderView::horizontalOffset(); }
|
|
|
inline QModelIndex promoted_indexAt(const QPoint& p) const { return QHeaderView::indexAt(p); }
|
|
|
inline bool promoted_isIndexHidden(const QModelIndex& index) const { return QHeaderView::isIndexHidden(index); }
|
|
|
inline void promoted_mouseDoubleClickEvent(QMouseEvent* e) { QHeaderView::mouseDoubleClickEvent(e); }
|
|
|
inline void promoted_mouseMoveEvent(QMouseEvent* e) { QHeaderView::mouseMoveEvent(e); }
|
|
|
inline void promoted_mousePressEvent(QMouseEvent* e) { QHeaderView::mousePressEvent(e); }
|
|
|
inline void promoted_mouseReleaseEvent(QMouseEvent* e) { QHeaderView::mouseReleaseEvent(e); }
|
|
|
inline void promoted_paintEvent(QPaintEvent* e) { QHeaderView::paintEvent(e); }
|
|
|
inline void promoted_paintSection(QPainter* painter, const QRect& rect, int logicalIndex) const { QHeaderView::paintSection(painter, rect, logicalIndex); }
|
|
|
inline void promoted_reset() { QHeaderView::reset(); }
|
|
|
inline void promoted_rowsInserted(const QModelIndex& parent, int start, int end) { QHeaderView::rowsInserted(parent, start, end); }
|
|
|
inline void promoted_scrollContentsBy(int dx, int dy) { QHeaderView::scrollContentsBy(dx, dy); }
|
|
|
inline void promoted_scrollTo(const QModelIndex& index, QAbstractItemView::ScrollHint hint) { QHeaderView::scrollTo(index, hint); }
|
|
|
inline QSize promoted_sectionSizeFromContents(int logicalIndex) const { return QHeaderView::sectionSizeFromContents(logicalIndex); }
|
|
|
inline void promoted_setModel(QAbstractItemModel* model) { QHeaderView::setModel(model); }
|
|
|
inline void promoted_setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags flags) { QHeaderView::setSelection(rect, flags); }
|
|
|
inline void promoted_updateGeometries() { QHeaderView::updateGeometries(); }
|
|
|
inline int promoted_verticalOffset() const { return QHeaderView::verticalOffset(); }
|
|
|
inline bool promoted_viewportEvent(QEvent* e) { return QHeaderView::viewportEvent(e); }
|
|
|
inline QRect promoted_visualRect(const QModelIndex& index) const { return QHeaderView::visualRect(index); }
|
|
|
inline QRegion promoted_visualRegionForSelection(const QItemSelection& selection) const { return QHeaderView::visualRegionForSelection(selection); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QHeaderView : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QHeaderView* new_QHeaderView(Qt::Orientation orientation, QWidget* parent = 0);
|
|
|
void delete_QHeaderView(QHeaderView* obj) { delete obj; }
|
|
|
bool cascadingSectionResizes(QHeaderView* theWrappedObject) const;
|
|
|
int count(QHeaderView* theWrappedObject) const;
|
|
|
void currentChanged(QHeaderView* theWrappedObject, const QModelIndex& current, const QModelIndex& old);
|
|
|
void dataChanged(QHeaderView* theWrappedObject, const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int >& roles = QVector<int>());
|
|
|
Qt::Alignment defaultAlignment(QHeaderView* theWrappedObject) const;
|
|
|
int defaultSectionSize(QHeaderView* theWrappedObject) const;
|
|
|
void doItemsLayout(QHeaderView* theWrappedObject);
|
|
|
bool event(QHeaderView* theWrappedObject, QEvent* e);
|
|
|
int hiddenSectionCount(QHeaderView* theWrappedObject) const;
|
|
|
void hideSection(QHeaderView* theWrappedObject, int logicalIndex);
|
|
|
bool highlightSections(QHeaderView* theWrappedObject) const;
|
|
|
int horizontalOffset(QHeaderView* theWrappedObject) const;
|
|
|
QModelIndex indexAt(QHeaderView* theWrappedObject, const QPoint& p) const;
|
|
|
bool isIndexHidden(QHeaderView* theWrappedObject, const QModelIndex& index) const;
|
|
|
bool isSectionHidden(QHeaderView* theWrappedObject, int logicalIndex) const;
|
|
|
bool isSortIndicatorShown(QHeaderView* theWrappedObject) const;
|
|
|
int length(QHeaderView* theWrappedObject) const;
|
|
|
int logicalIndex(QHeaderView* theWrappedObject, int visualIndex) const;
|
|
|
int logicalIndexAt(QHeaderView* theWrappedObject, const QPoint& pos) const;
|
|
|
int logicalIndexAt(QHeaderView* theWrappedObject, int position) const;
|
|
|
int logicalIndexAt(QHeaderView* theWrappedObject, int x, int y) const;
|
|
|
int minimumSectionSize(QHeaderView* theWrappedObject) const;
|
|
|
void mouseDoubleClickEvent(QHeaderView* theWrappedObject, QMouseEvent* e);
|
|
|
void mouseMoveEvent(QHeaderView* theWrappedObject, QMouseEvent* e);
|
|
|
void mousePressEvent(QHeaderView* theWrappedObject, QMouseEvent* e);
|
|
|
void mouseReleaseEvent(QHeaderView* theWrappedObject, QMouseEvent* e);
|
|
|
void moveSection(QHeaderView* theWrappedObject, int from, int to);
|
|
|
int offset(QHeaderView* theWrappedObject) const;
|
|
|
Qt::Orientation orientation(QHeaderView* theWrappedObject) const;
|
|
|
void paintEvent(QHeaderView* theWrappedObject, QPaintEvent* e);
|
|
|
void paintSection(QHeaderView* theWrappedObject, QPainter* painter, const QRect& rect, int logicalIndex) const;
|
|
|
void reset(QHeaderView* theWrappedObject);
|
|
|
void resizeSection(QHeaderView* theWrappedObject, int logicalIndex, int size);
|
|
|
void resizeSections(QHeaderView* theWrappedObject, QHeaderView::ResizeMode mode);
|
|
|
bool restoreState(QHeaderView* theWrappedObject, const QByteArray& state);
|
|
|
void rowsInserted(QHeaderView* theWrappedObject, const QModelIndex& parent, int start, int end);
|
|
|
QByteArray saveState(QHeaderView* theWrappedObject) const;
|
|
|
void scrollContentsBy(QHeaderView* theWrappedObject, int dx, int dy);
|
|
|
void scrollTo(QHeaderView* theWrappedObject, const QModelIndex& index, QAbstractItemView::ScrollHint hint);
|
|
|
int sectionPosition(QHeaderView* theWrappedObject, int logicalIndex) const;
|
|
|
QHeaderView::ResizeMode sectionResizeMode(QHeaderView* theWrappedObject, int logicalIndex) const;
|
|
|
int sectionSize(QHeaderView* theWrappedObject, int logicalIndex) const;
|
|
|
QSize sectionSizeFromContents(QHeaderView* theWrappedObject, int logicalIndex) const;
|
|
|
int sectionSizeHint(QHeaderView* theWrappedObject, int logicalIndex) const;
|
|
|
int sectionViewportPosition(QHeaderView* theWrappedObject, int logicalIndex) const;
|
|
|
bool sectionsClickable(QHeaderView* theWrappedObject) const;
|
|
|
bool sectionsHidden(QHeaderView* theWrappedObject) const;
|
|
|
bool sectionsMovable(QHeaderView* theWrappedObject) const;
|
|
|
bool sectionsMoved(QHeaderView* theWrappedObject) const;
|
|
|
void setCascadingSectionResizes(QHeaderView* theWrappedObject, bool enable);
|
|
|
void setDefaultAlignment(QHeaderView* theWrappedObject, Qt::Alignment alignment);
|
|
|
void setDefaultSectionSize(QHeaderView* theWrappedObject, int size);
|
|
|
void setHighlightSections(QHeaderView* theWrappedObject, bool highlight);
|
|
|
void setMinimumSectionSize(QHeaderView* theWrappedObject, int size);
|
|
|
void setModel(QHeaderView* theWrappedObject, QAbstractItemModel* model);
|
|
|
void setSectionHidden(QHeaderView* theWrappedObject, int logicalIndex, bool hide);
|
|
|
void setSectionResizeMode(QHeaderView* theWrappedObject, QHeaderView::ResizeMode mode);
|
|
|
void setSectionResizeMode(QHeaderView* theWrappedObject, int logicalIndex, QHeaderView::ResizeMode mode);
|
|
|
void setSectionsClickable(QHeaderView* theWrappedObject, bool clickable);
|
|
|
void setSectionsMovable(QHeaderView* theWrappedObject, bool movable);
|
|
|
void setSelection(QHeaderView* theWrappedObject, const QRect& rect, QItemSelectionModel::SelectionFlags flags);
|
|
|
void setSortIndicator(QHeaderView* theWrappedObject, int logicalIndex, Qt::SortOrder order);
|
|
|
void setSortIndicatorShown(QHeaderView* theWrappedObject, bool show);
|
|
|
void setStretchLastSection(QHeaderView* theWrappedObject, bool stretch);
|
|
|
void showSection(QHeaderView* theWrappedObject, int logicalIndex);
|
|
|
QSize sizeHint(QHeaderView* theWrappedObject) const;
|
|
|
Qt::SortOrder sortIndicatorOrder(QHeaderView* theWrappedObject) const;
|
|
|
int sortIndicatorSection(QHeaderView* theWrappedObject) const;
|
|
|
bool stretchLastSection(QHeaderView* theWrappedObject) const;
|
|
|
int stretchSectionCount(QHeaderView* theWrappedObject) const;
|
|
|
void swapSections(QHeaderView* theWrappedObject, int first, int second);
|
|
|
void updateGeometries(QHeaderView* theWrappedObject);
|
|
|
int verticalOffset(QHeaderView* theWrappedObject) const;
|
|
|
bool viewportEvent(QHeaderView* theWrappedObject, QEvent* e);
|
|
|
int visualIndex(QHeaderView* theWrappedObject, int logicalIndex) const;
|
|
|
int visualIndexAt(QHeaderView* theWrappedObject, int position) const;
|
|
|
QRect visualRect(QHeaderView* theWrappedObject, const QModelIndex& index) const;
|
|
|
QRegion visualRegionForSelection(QHeaderView* theWrappedObject, const QItemSelection& selection) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QHelpEvent : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QHelpEvent* new_QHelpEvent(QEvent::Type type, const QPoint& pos, const QPoint& globalPos);
|
|
|
void delete_QHelpEvent(QHelpEvent* obj) { delete obj; }
|
|
|
const QPoint* globalPos(QHelpEvent* theWrappedObject) const;
|
|
|
int globalX(QHelpEvent* theWrappedObject) const;
|
|
|
int globalY(QHelpEvent* theWrappedObject) const;
|
|
|
const QPoint* pos(QHelpEvent* theWrappedObject) const;
|
|
|
int x(QHelpEvent* theWrappedObject) const;
|
|
|
int y(QHelpEvent* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QHideEvent : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QHideEvent* new_QHideEvent();
|
|
|
void delete_QHideEvent(QHideEvent* obj) { delete obj; }
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QHoverEvent : public QHoverEvent
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QHoverEvent(QEvent::Type type, const QPointF& pos, const QPointF& oldPos, Qt::KeyboardModifiers modifiers = Qt::NoModifier):QHoverEvent(type, pos, oldPos, modifiers),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QHoverEvent();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QHoverEvent : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QHoverEvent* new_QHoverEvent(QEvent::Type type, const QPointF& pos, const QPointF& oldPos, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
|
|
|
void delete_QHoverEvent(QHoverEvent* obj) { delete obj; }
|
|
|
QPoint oldPos(QHoverEvent* theWrappedObject) const;
|
|
|
const QPointF* oldPosF(QHoverEvent* theWrappedObject) const;
|
|
|
QPoint pos(QHoverEvent* theWrappedObject) const;
|
|
|
const QPointF* posF(QHoverEvent* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QIconDragEvent : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QIconDragEvent* new_QIconDragEvent();
|
|
|
void delete_QIconDragEvent(QIconDragEvent* obj) { delete obj; }
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QImageIOHandler : public QImageIOHandler
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QImageIOHandler():QImageIOHandler(),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QImageIOHandler();
|
|
|
|
|
|
virtual bool canRead() const;
|
|
|
virtual int currentImageNumber() const;
|
|
|
virtual QRect currentImageRect() const;
|
|
|
virtual int imageCount() const;
|
|
|
virtual bool jumpToImage(int imageNumber);
|
|
|
virtual bool jumpToNextImage();
|
|
|
virtual int loopCount() const;
|
|
|
virtual QByteArray name() const;
|
|
|
virtual int nextImageDelay() const;
|
|
|
virtual QVariant option(QImageIOHandler::ImageOption option) const;
|
|
|
virtual bool read(QImage* image);
|
|
|
virtual void setOption(QImageIOHandler::ImageOption option, const QVariant& value);
|
|
|
virtual bool supportsOption(QImageIOHandler::ImageOption option) const;
|
|
|
virtual bool write(const QImage& image);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QImageIOHandler : public QImageIOHandler
|
|
|
{ public:
|
|
|
inline int promoted_currentImageNumber() const { return QImageIOHandler::currentImageNumber(); }
|
|
|
inline QRect promoted_currentImageRect() const { return QImageIOHandler::currentImageRect(); }
|
|
|
inline int promoted_imageCount() const { return QImageIOHandler::imageCount(); }
|
|
|
inline bool promoted_jumpToImage(int imageNumber) { return QImageIOHandler::jumpToImage(imageNumber); }
|
|
|
inline bool promoted_jumpToNextImage() { return QImageIOHandler::jumpToNextImage(); }
|
|
|
inline int promoted_loopCount() const { return QImageIOHandler::loopCount(); }
|
|
|
inline int promoted_nextImageDelay() const { return QImageIOHandler::nextImageDelay(); }
|
|
|
inline QVariant promoted_option(QImageIOHandler::ImageOption option) const { return QImageIOHandler::option(option); }
|
|
|
inline void promoted_setOption(QImageIOHandler::ImageOption option, const QVariant& value) { QImageIOHandler::setOption(option, value); }
|
|
|
inline bool promoted_supportsOption(QImageIOHandler::ImageOption option) const { return QImageIOHandler::supportsOption(option); }
|
|
|
inline bool promoted_write(const QImage& image) { return QImageIOHandler::write(image); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QImageIOHandler : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(ImageOption )
|
|
|
enum ImageOption{
|
|
|
Size = QImageIOHandler::Size, ClipRect = QImageIOHandler::ClipRect, Description = QImageIOHandler::Description, ScaledClipRect = QImageIOHandler::ScaledClipRect, ScaledSize = QImageIOHandler::ScaledSize, CompressionRatio = QImageIOHandler::CompressionRatio, Gamma = QImageIOHandler::Gamma, Quality = QImageIOHandler::Quality, Name = QImageIOHandler::Name, SubType = QImageIOHandler::SubType, IncrementalReading = QImageIOHandler::IncrementalReading, Endianness = QImageIOHandler::Endianness, Animation = QImageIOHandler::Animation, BackgroundColor = QImageIOHandler::BackgroundColor, ImageFormat = QImageIOHandler::ImageFormat};
|
|
|
public slots:
|
|
|
QImageIOHandler* new_QImageIOHandler();
|
|
|
void delete_QImageIOHandler(QImageIOHandler* obj) { delete obj; }
|
|
|
int currentImageNumber(QImageIOHandler* theWrappedObject) const;
|
|
|
QRect currentImageRect(QImageIOHandler* theWrappedObject) const;
|
|
|
QIODevice* device(QImageIOHandler* theWrappedObject) const;
|
|
|
QByteArray format(QImageIOHandler* theWrappedObject) const;
|
|
|
int imageCount(QImageIOHandler* theWrappedObject) const;
|
|
|
bool jumpToImage(QImageIOHandler* theWrappedObject, int imageNumber);
|
|
|
bool jumpToNextImage(QImageIOHandler* theWrappedObject);
|
|
|
int loopCount(QImageIOHandler* theWrappedObject) const;
|
|
|
int nextImageDelay(QImageIOHandler* theWrappedObject) const;
|
|
|
QVariant option(QImageIOHandler* theWrappedObject, QImageIOHandler::ImageOption option) const;
|
|
|
void setDevice(QImageIOHandler* theWrappedObject, QIODevice* device);
|
|
|
void setFormat(QImageIOHandler* theWrappedObject, const QByteArray& format);
|
|
|
void setOption(QImageIOHandler* theWrappedObject, QImageIOHandler::ImageOption option, const QVariant& value);
|
|
|
bool supportsOption(QImageIOHandler* theWrappedObject, QImageIOHandler::ImageOption option) const;
|
|
|
bool write(QImageIOHandler* theWrappedObject, const QImage& image);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QImageIOPlugin : public QImageIOPlugin
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QImageIOPlugin(QObject* parent = 0):QImageIOPlugin(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QImageIOPlugin();
|
|
|
|
|
|
virtual QImageIOPlugin::Capabilities capabilities(QIODevice* device, const QByteArray& format) const;
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual QImageIOHandler* create(QIODevice* device, const QByteArray& format = QByteArray()) const;
|
|
|
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_QImageIOPlugin : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(Capability )
|
|
|
Q_FLAGS(Capabilities )
|
|
|
enum Capability{
|
|
|
CanRead = QImageIOPlugin::CanRead, CanWrite = QImageIOPlugin::CanWrite, CanReadIncremental = QImageIOPlugin::CanReadIncremental};
|
|
|
Q_DECLARE_FLAGS(Capabilities, Capability)
|
|
|
public slots:
|
|
|
QImageIOPlugin* new_QImageIOPlugin(QObject* parent = 0);
|
|
|
void delete_QImageIOPlugin(QImageIOPlugin* obj) { delete obj; }
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QImageReader : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(ImageReaderError )
|
|
|
enum ImageReaderError{
|
|
|
UnknownError = QImageReader::UnknownError, FileNotFoundError = QImageReader::FileNotFoundError, DeviceError = QImageReader::DeviceError, UnsupportedFormatError = QImageReader::UnsupportedFormatError, InvalidDataError = QImageReader::InvalidDataError};
|
|
|
public slots:
|
|
|
QImageReader* new_QImageReader();
|
|
|
QImageReader* new_QImageReader(QIODevice* device, const QByteArray& format = QByteArray());
|
|
|
QImageReader* new_QImageReader(const QString& fileName, const QByteArray& format = QByteArray());
|
|
|
void delete_QImageReader(QImageReader* obj) { delete obj; }
|
|
|
bool autoDetectImageFormat(QImageReader* theWrappedObject) const;
|
|
|
QColor backgroundColor(QImageReader* theWrappedObject) const;
|
|
|
bool canRead(QImageReader* theWrappedObject) const;
|
|
|
QRect clipRect(QImageReader* theWrappedObject) const;
|
|
|
int currentImageNumber(QImageReader* theWrappedObject) const;
|
|
|
QRect currentImageRect(QImageReader* theWrappedObject) const;
|
|
|
bool decideFormatFromContent(QImageReader* theWrappedObject) const;
|
|
|
QIODevice* device(QImageReader* theWrappedObject) const;
|
|
|
QImageReader::ImageReaderError error(QImageReader* theWrappedObject) const;
|
|
|
QString errorString(QImageReader* theWrappedObject) const;
|
|
|
QString fileName(QImageReader* theWrappedObject) const;
|
|
|
QByteArray format(QImageReader* theWrappedObject) const;
|
|
|
int imageCount(QImageReader* theWrappedObject) const;
|
|
|
QImage::Format imageFormat(QImageReader* theWrappedObject) const;
|
|
|
QByteArray static_QImageReader_imageFormat(QIODevice* device);
|
|
|
QByteArray static_QImageReader_imageFormat(const QString& fileName);
|
|
|
bool jumpToImage(QImageReader* theWrappedObject, int imageNumber);
|
|
|
bool jumpToNextImage(QImageReader* theWrappedObject);
|
|
|
int loopCount(QImageReader* theWrappedObject) const;
|
|
|
int nextImageDelay(QImageReader* theWrappedObject) const;
|
|
|
int quality(QImageReader* theWrappedObject) const;
|
|
|
QImage read(QImageReader* theWrappedObject);
|
|
|
QRect scaledClipRect(QImageReader* theWrappedObject) const;
|
|
|
QSize scaledSize(QImageReader* theWrappedObject) const;
|
|
|
void setAutoDetectImageFormat(QImageReader* theWrappedObject, bool enabled);
|
|
|
void setBackgroundColor(QImageReader* theWrappedObject, const QColor& color);
|
|
|
void setClipRect(QImageReader* theWrappedObject, const QRect& rect);
|
|
|
void setDecideFormatFromContent(QImageReader* theWrappedObject, bool ignored);
|
|
|
void setDevice(QImageReader* theWrappedObject, QIODevice* device);
|
|
|
void setFileName(QImageReader* theWrappedObject, const QString& fileName);
|
|
|
void setFormat(QImageReader* theWrappedObject, const QByteArray& format);
|
|
|
void setQuality(QImageReader* theWrappedObject, int quality);
|
|
|
void setScaledClipRect(QImageReader* theWrappedObject, const QRect& rect);
|
|
|
void setScaledSize(QImageReader* theWrappedObject, const QSize& size);
|
|
|
QSize size(QImageReader* theWrappedObject) const;
|
|
|
QList<QByteArray > static_QImageReader_supportedImageFormats();
|
|
|
bool supportsAnimation(QImageReader* theWrappedObject) const;
|
|
|
bool supportsOption(QImageReader* theWrappedObject, QImageIOHandler::ImageOption option) const;
|
|
|
QString text(QImageReader* theWrappedObject, const QString& key) const;
|
|
|
QStringList textKeys(QImageReader* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QImageWriter : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(ImageWriterError )
|
|
|
enum ImageWriterError{
|
|
|
UnknownError = QImageWriter::UnknownError, DeviceError = QImageWriter::DeviceError, UnsupportedFormatError = QImageWriter::UnsupportedFormatError};
|
|
|
public slots:
|
|
|
QImageWriter* new_QImageWriter();
|
|
|
QImageWriter* new_QImageWriter(QIODevice* device, const QByteArray& format);
|
|
|
QImageWriter* new_QImageWriter(const QString& fileName, const QByteArray& format = QByteArray());
|
|
|
void delete_QImageWriter(QImageWriter* obj) { delete obj; }
|
|
|
bool canWrite(QImageWriter* theWrappedObject) const;
|
|
|
int compression(QImageWriter* theWrappedObject) const;
|
|
|
QIODevice* device(QImageWriter* theWrappedObject) const;
|
|
|
QImageWriter::ImageWriterError error(QImageWriter* theWrappedObject) const;
|
|
|
QString errorString(QImageWriter* theWrappedObject) const;
|
|
|
QString fileName(QImageWriter* theWrappedObject) const;
|
|
|
QByteArray format(QImageWriter* theWrappedObject) const;
|
|
|
float gamma(QImageWriter* theWrappedObject) const;
|
|
|
int quality(QImageWriter* theWrappedObject) const;
|
|
|
void setCompression(QImageWriter* theWrappedObject, int compression);
|
|
|
void setDevice(QImageWriter* theWrappedObject, QIODevice* device);
|
|
|
void setFileName(QImageWriter* theWrappedObject, const QString& fileName);
|
|
|
void setFormat(QImageWriter* theWrappedObject, const QByteArray& format);
|
|
|
void setGamma(QImageWriter* theWrappedObject, float gamma);
|
|
|
void setQuality(QImageWriter* theWrappedObject, int quality);
|
|
|
void setText(QImageWriter* theWrappedObject, const QString& key, const QString& text);
|
|
|
QList<QByteArray > static_QImageWriter_supportedImageFormats();
|
|
|
bool supportsOption(QImageWriter* theWrappedObject, QImageIOHandler::ImageOption option) const;
|
|
|
bool write(QImageWriter* theWrappedObject, const QImage& image);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QInputDialog : public QInputDialog
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QInputDialog(QWidget* parent = 0, Qt::WindowFlags flags = 0):QInputDialog(parent, flags),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QInputDialog();
|
|
|
|
|
|
virtual void accept();
|
|
|
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 done(int result);
|
|
|
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 int exec();
|
|
|
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 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 void open();
|
|
|
virtual QPaintEngine* paintEngine() const;
|
|
|
virtual void paintEvent(QPaintEvent* arg__1);
|
|
|
virtual QPaintDevice* redirected(QPoint* offset) const;
|
|
|
virtual void reject();
|
|
|
virtual void resizeEvent(QResizeEvent* arg__1);
|
|
|
virtual QPainter* sharedPainter() const;
|
|
|
virtual void showEvent(QShowEvent* arg__1);
|
|
|
virtual void tabletEvent(QTabletEvent* arg__1);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
virtual void wheelEvent(QWheelEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QInputDialog : public QInputDialog
|
|
|
{ public:
|
|
|
inline void promoted_done(int result) { QInputDialog::done(result); }
|
|
|
inline void promoted_open() { QInputDialog::open(); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QInputDialog : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(InputDialogOption InputMode )
|
|
|
Q_FLAGS(InputDialogOptions )
|
|
|
enum InputDialogOption{
|
|
|
NoButtons = QInputDialog::NoButtons, UseListViewForComboBoxItems = QInputDialog::UseListViewForComboBoxItems};
|
|
|
enum InputMode{
|
|
|
TextInput = QInputDialog::TextInput, IntInput = QInputDialog::IntInput, DoubleInput = QInputDialog::DoubleInput};
|
|
|
Q_DECLARE_FLAGS(InputDialogOptions, InputDialogOption)
|
|
|
public slots:
|
|
|
QInputDialog* new_QInputDialog(QWidget* parent = 0, Qt::WindowFlags flags = 0);
|
|
|
void delete_QInputDialog(QInputDialog* obj) { delete obj; }
|
|
|
QString cancelButtonText(QInputDialog* theWrappedObject) const;
|
|
|
QStringList comboBoxItems(QInputDialog* theWrappedObject) const;
|
|
|
void done(QInputDialog* theWrappedObject, int result);
|
|
|
int doubleDecimals(QInputDialog* theWrappedObject) const;
|
|
|
double doubleMaximum(QInputDialog* theWrappedObject) const;
|
|
|
double doubleMinimum(QInputDialog* theWrappedObject) const;
|
|
|
double doubleValue(QInputDialog* theWrappedObject) const;
|
|
|
double static_QInputDialog_getDouble(QWidget* parent, const QString& title, const QString& label, double value = 0, double minValue = -2147483647, double maxValue = 2147483647, int decimals = 1, bool* ok = 0, Qt::WindowFlags flags = 0);
|
|
|
int static_QInputDialog_getInt(QWidget* parent, const QString& title, const QString& label, int value = 0, int minValue = -2147483647, int maxValue = 2147483647, int step = 1, bool* ok = 0, Qt::WindowFlags flags = 0);
|
|
|
QString static_QInputDialog_getItem(QWidget* parent, const QString& title, const QString& label, const QStringList& items, int current = 0, bool editable = true, bool* ok = 0, Qt::WindowFlags flags = 0, Qt::InputMethodHints inputMethodHints = Qt::ImhNone);
|
|
|
QString static_QInputDialog_getText(QWidget* parent, const QString& title, const QString& label, QLineEdit::EchoMode echo = QLineEdit::Normal, const QString& text = QString(), bool* ok = 0, Qt::WindowFlags flags = 0, Qt::InputMethodHints inputMethodHints = Qt::ImhNone);
|
|
|
QInputDialog::InputMode inputMode(QInputDialog* theWrappedObject) const;
|
|
|
int intMaximum(QInputDialog* theWrappedObject) const;
|
|
|
int intMinimum(QInputDialog* theWrappedObject) const;
|
|
|
int intStep(QInputDialog* theWrappedObject) const;
|
|
|
int intValue(QInputDialog* theWrappedObject) const;
|
|
|
bool isComboBoxEditable(QInputDialog* theWrappedObject) const;
|
|
|
QString labelText(QInputDialog* theWrappedObject) const;
|
|
|
QSize minimumSizeHint(QInputDialog* theWrappedObject) const;
|
|
|
QString okButtonText(QInputDialog* theWrappedObject) const;
|
|
|
void open(QInputDialog* theWrappedObject);
|
|
|
void open(QInputDialog* theWrappedObject, QObject* receiver, const char* member);
|
|
|
QInputDialog::InputDialogOptions options(QInputDialog* theWrappedObject) const;
|
|
|
void setCancelButtonText(QInputDialog* theWrappedObject, const QString& text);
|
|
|
void setComboBoxEditable(QInputDialog* theWrappedObject, bool editable);
|
|
|
void setComboBoxItems(QInputDialog* theWrappedObject, const QStringList& items);
|
|
|
void setDoubleDecimals(QInputDialog* theWrappedObject, int decimals);
|
|
|
void setDoubleMaximum(QInputDialog* theWrappedObject, double max);
|
|
|
void setDoubleMinimum(QInputDialog* theWrappedObject, double min);
|
|
|
void setDoubleRange(QInputDialog* theWrappedObject, double min, double max);
|
|
|
void setDoubleValue(QInputDialog* theWrappedObject, double value);
|
|
|
void setInputMode(QInputDialog* theWrappedObject, QInputDialog::InputMode mode);
|
|
|
void setIntMaximum(QInputDialog* theWrappedObject, int max);
|
|
|
void setIntMinimum(QInputDialog* theWrappedObject, int min);
|
|
|
void setIntRange(QInputDialog* theWrappedObject, int min, int max);
|
|
|
void setIntStep(QInputDialog* theWrappedObject, int step);
|
|
|
void setIntValue(QInputDialog* theWrappedObject, int value);
|
|
|
void setLabelText(QInputDialog* theWrappedObject, const QString& text);
|
|
|
void setOkButtonText(QInputDialog* theWrappedObject, const QString& text);
|
|
|
void setOption(QInputDialog* theWrappedObject, QInputDialog::InputDialogOption option, bool on = true);
|
|
|
void setOptions(QInputDialog* theWrappedObject, QInputDialog::InputDialogOptions options);
|
|
|
void setTextEchoMode(QInputDialog* theWrappedObject, QLineEdit::EchoMode mode);
|
|
|
void setTextValue(QInputDialog* theWrappedObject, const QString& text);
|
|
|
void setVisible(QInputDialog* theWrappedObject, bool visible);
|
|
|
QSize sizeHint(QInputDialog* theWrappedObject) const;
|
|
|
bool testOption(QInputDialog* theWrappedObject, QInputDialog::InputDialogOption option) const;
|
|
|
QLineEdit::EchoMode textEchoMode(QInputDialog* theWrappedObject) const;
|
|
|
QString textValue(QInputDialog* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QInputEvent : public QInputEvent
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QInputEvent(QEvent::Type type, Qt::KeyboardModifiers modifiers = Qt::NoModifier):QInputEvent(type, modifiers),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QInputEvent();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QInputEvent : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QInputEvent* new_QInputEvent(QEvent::Type type, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
|
|
|
void delete_QInputEvent(QInputEvent* obj) { delete obj; }
|
|
|
Qt::KeyboardModifiers modifiers(QInputEvent* theWrappedObject) const;
|
|
|
void setModifiers(QInputEvent* theWrappedObject, Qt::KeyboardModifiers amodifiers);
|
|
|
void setTimestamp(QInputEvent* theWrappedObject, ulong atimestamp);
|
|
|
ulong timestamp(QInputEvent* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QIntValidator : public QIntValidator
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QIntValidator(QObject* parent = 0):QIntValidator(parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QIntValidator(int bottom, int top, QObject* parent = 0):QIntValidator(bottom, top, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QIntValidator();
|
|
|
|
|
|
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 fixup(QString& input) const;
|
|
|
virtual void setRange(int bottom, int top);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
virtual QValidator::State validate(QString& arg__1, int& arg__2) const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QIntValidator : public QIntValidator
|
|
|
{ public:
|
|
|
inline void promoted_fixup(QString& input) const { QIntValidator::fixup(input); }
|
|
|
inline void promoted_setRange(int bottom, int top) { QIntValidator::setRange(bottom, top); }
|
|
|
inline QValidator::State promoted_validate(QString& arg__1, int& arg__2) const { return QIntValidator::validate(arg__1, arg__2); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QIntValidator : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QIntValidator* new_QIntValidator(QObject* parent = 0);
|
|
|
QIntValidator* new_QIntValidator(int bottom, int top, QObject* parent = 0);
|
|
|
void delete_QIntValidator(QIntValidator* obj) { delete obj; }
|
|
|
int bottom(QIntValidator* theWrappedObject) const;
|
|
|
void fixup(QIntValidator* theWrappedObject, QString& input) const;
|
|
|
void setBottom(QIntValidator* theWrappedObject, int arg__1);
|
|
|
void setRange(QIntValidator* theWrappedObject, int bottom, int top);
|
|
|
void setTop(QIntValidator* theWrappedObject, int arg__1);
|
|
|
int top(QIntValidator* theWrappedObject) const;
|
|
|
QValidator::State validate(QIntValidator* theWrappedObject, QString& arg__1, int& arg__2) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QItemDelegate : public QItemDelegate
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QItemDelegate(QObject* parent = 0):QItemDelegate(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QItemDelegate();
|
|
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const;
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual void destroyEditor(QWidget* editor, const QModelIndex& index) const;
|
|
|
virtual void drawCheck(QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, Qt::CheckState state) const;
|
|
|
virtual void drawDecoration(QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, const QPixmap& pixmap) const;
|
|
|
virtual void drawDisplay(QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, const QString& text) const;
|
|
|
virtual void drawFocus(QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect) const;
|
|
|
virtual bool editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* object, QEvent* event);
|
|
|
virtual bool helpEvent(QHelpEvent* event, QAbstractItemView* view, const QStyleOptionViewItem& option, const QModelIndex& index);
|
|
|
virtual void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const;
|
|
|
virtual QVector<int > paintingRoles() const;
|
|
|
virtual void setEditorData(QWidget* editor, const QModelIndex& index) const;
|
|
|
virtual void setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const;
|
|
|
virtual QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const;
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
virtual void updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QItemDelegate : public QItemDelegate
|
|
|
{ public:
|
|
|
inline QWidget* promoted_createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const { return QItemDelegate::createEditor(parent, option, index); }
|
|
|
inline void promoted_drawCheck(QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, Qt::CheckState state) const { QItemDelegate::drawCheck(painter, option, rect, state); }
|
|
|
inline void promoted_drawDecoration(QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, const QPixmap& pixmap) const { QItemDelegate::drawDecoration(painter, option, rect, pixmap); }
|
|
|
inline void promoted_drawDisplay(QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, const QString& text) const { QItemDelegate::drawDisplay(painter, option, rect, text); }
|
|
|
inline void promoted_drawFocus(QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect) const { QItemDelegate::drawFocus(painter, option, rect); }
|
|
|
inline bool promoted_editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index) { return QItemDelegate::editorEvent(event, model, option, index); }
|
|
|
inline bool promoted_eventFilter(QObject* object, QEvent* event) { return QItemDelegate::eventFilter(object, event); }
|
|
|
inline void promoted_paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const { QItemDelegate::paint(painter, option, index); }
|
|
|
inline void promoted_setEditorData(QWidget* editor, const QModelIndex& index) const { QItemDelegate::setEditorData(editor, index); }
|
|
|
inline void promoted_setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const { QItemDelegate::setModelData(editor, model, index); }
|
|
|
inline QSize promoted_sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const { return QItemDelegate::sizeHint(option, index); }
|
|
|
inline void promoted_updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const { QItemDelegate::updateEditorGeometry(editor, option, index); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QItemDelegate : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QItemDelegate* new_QItemDelegate(QObject* parent = 0);
|
|
|
void delete_QItemDelegate(QItemDelegate* obj) { delete obj; }
|
|
|
QWidget* createEditor(QItemDelegate* theWrappedObject, QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const;
|
|
|
void drawCheck(QItemDelegate* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, Qt::CheckState state) const;
|
|
|
void drawDecoration(QItemDelegate* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, const QPixmap& pixmap) const;
|
|
|
void drawDisplay(QItemDelegate* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, const QString& text) const;
|
|
|
void drawFocus(QItemDelegate* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect) const;
|
|
|
bool editorEvent(QItemDelegate* theWrappedObject, QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index);
|
|
|
bool eventFilter(QItemDelegate* theWrappedObject, QObject* object, QEvent* event);
|
|
|
bool hasClipping(QItemDelegate* theWrappedObject) const;
|
|
|
QItemEditorFactory* itemEditorFactory(QItemDelegate* theWrappedObject) const;
|
|
|
void paint(QItemDelegate* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const;
|
|
|
void setClipping(QItemDelegate* theWrappedObject, bool clip);
|
|
|
void setEditorData(QItemDelegate* theWrappedObject, QWidget* editor, const QModelIndex& index) const;
|
|
|
void setItemEditorFactory(QItemDelegate* theWrappedObject, QItemEditorFactory* factory);
|
|
|
void setModelData(QItemDelegate* theWrappedObject, QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const;
|
|
|
QSize sizeHint(QItemDelegate* theWrappedObject, const QStyleOptionViewItem& option, const QModelIndex& index) const;
|
|
|
void updateEditorGeometry(QItemDelegate* theWrappedObject, QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QItemEditorCreatorBase : public QItemEditorCreatorBase
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QItemEditorCreatorBase():QItemEditorCreatorBase(),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QItemEditorCreatorBase();
|
|
|
|
|
|
virtual QWidget* createWidget(QWidget* parent) const;
|
|
|
virtual QByteArray valuePropertyName() const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QItemEditorCreatorBase : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QItemEditorCreatorBase* new_QItemEditorCreatorBase();
|
|
|
void delete_QItemEditorCreatorBase(QItemEditorCreatorBase* obj) { delete obj; }
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QItemEditorFactory : public QItemEditorFactory
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QItemEditorFactory():QItemEditorFactory(),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QItemEditorFactory();
|
|
|
|
|
|
virtual QWidget* createEditor(int userType, QWidget* parent) const;
|
|
|
virtual QByteArray valuePropertyName(int userType) const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QItemEditorFactory : public QItemEditorFactory
|
|
|
{ public:
|
|
|
inline QWidget* promoted_createEditor(int userType, QWidget* parent) const { return QItemEditorFactory::createEditor(userType, parent); }
|
|
|
inline QByteArray promoted_valuePropertyName(int userType) const { return QItemEditorFactory::valuePropertyName(userType); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QItemEditorFactory : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QItemEditorFactory* new_QItemEditorFactory();
|
|
|
void delete_QItemEditorFactory(QItemEditorFactory* obj) { delete obj; }
|
|
|
QWidget* createEditor(QItemEditorFactory* theWrappedObject, int userType, QWidget* parent) const;
|
|
|
const QItemEditorFactory* static_QItemEditorFactory_defaultFactory();
|
|
|
void registerEditor(QItemEditorFactory* theWrappedObject, int userType, QItemEditorCreatorBase* creator);
|
|
|
void static_QItemEditorFactory_setDefaultFactory(QItemEditorFactory* factory);
|
|
|
QByteArray valuePropertyName(QItemEditorFactory* theWrappedObject, int userType) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QItemSelection : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QItemSelection* new_QItemSelection();
|
|
|
QItemSelection* new_QItemSelection(const QModelIndex& topLeft, const QModelIndex& bottomRight);
|
|
|
QItemSelection* new_QItemSelection(const QItemSelection& other) {
|
|
|
QItemSelection* a = new QItemSelection();
|
|
|
*((QItemSelection*)a) = other;
|
|
|
return a; }
|
|
|
void delete_QItemSelection(QItemSelection* obj) { delete obj; }
|
|
|
void append(QItemSelection* theWrappedObject, const QItemSelectionRange& t);
|
|
|
void append(QItemSelection* theWrappedObject, const QList<QItemSelectionRange >& t);
|
|
|
const QItemSelectionRange* at(QItemSelection* theWrappedObject, int i) const;
|
|
|
const QItemSelectionRange* back(QItemSelection* theWrappedObject) const;
|
|
|
void clear(QItemSelection* theWrappedObject);
|
|
|
bool contains(QItemSelection* theWrappedObject, const QModelIndex& index) const;
|
|
|
int count(QItemSelection* theWrappedObject) const;
|
|
|
int count(QItemSelection* theWrappedObject, const QItemSelectionRange& t) const;
|
|
|
void detachShared(QItemSelection* theWrappedObject);
|
|
|
bool empty(QItemSelection* theWrappedObject) const;
|
|
|
bool endsWith(QItemSelection* theWrappedObject, const QItemSelectionRange& t) const;
|
|
|
const QItemSelectionRange* first(QItemSelection* theWrappedObject) const;
|
|
|
QList<QItemSelectionRange > static_QItemSelection_fromVector(const QVector<QItemSelectionRange >& vector);
|
|
|
const QItemSelectionRange* front(QItemSelection* theWrappedObject) const;
|
|
|
int indexOf(QItemSelection* theWrappedObject, const QItemSelectionRange& t, int from) const;
|
|
|
QList<QModelIndex > indexes(QItemSelection* theWrappedObject) const;
|
|
|
bool isEmpty(QItemSelection* theWrappedObject) const;
|
|
|
bool isSharedWith(QItemSelection* theWrappedObject, const QList<QItemSelectionRange >& other) const;
|
|
|
const QItemSelectionRange* last(QItemSelection* theWrappedObject) const;
|
|
|
int lastIndexOf(QItemSelection* theWrappedObject, const QItemSelectionRange& t, int from) const;
|
|
|
int length(QItemSelection* theWrappedObject) const;
|
|
|
void merge(QItemSelection* theWrappedObject, const QItemSelection& other, QItemSelectionModel::SelectionFlags command);
|
|
|
QList<QItemSelectionRange > mid(QItemSelection* theWrappedObject, int pos, int length) const;
|
|
|
void move(QItemSelection* theWrappedObject, int from, int to);
|
|
|
bool __ne__(QItemSelection* theWrappedObject, const QList<QItemSelectionRange >& l) const;
|
|
|
bool __eq__(QItemSelection* theWrappedObject, const QList<QItemSelectionRange >& l) const;
|
|
|
void pop_back(QItemSelection* theWrappedObject);
|
|
|
void pop_front(QItemSelection* theWrappedObject);
|
|
|
void prepend(QItemSelection* theWrappedObject, const QItemSelectionRange& t);
|
|
|
void push_back(QItemSelection* theWrappedObject, const QItemSelectionRange& t);
|
|
|
void push_front(QItemSelection* theWrappedObject, const QItemSelectionRange& t);
|
|
|
int removeAll(QItemSelection* theWrappedObject, const QItemSelectionRange& t);
|
|
|
void removeAt(QItemSelection* theWrappedObject, int i);
|
|
|
void removeFirst(QItemSelection* theWrappedObject);
|
|
|
void removeLast(QItemSelection* theWrappedObject);
|
|
|
bool removeOne(QItemSelection* theWrappedObject, const QItemSelectionRange& t);
|
|
|
void replace(QItemSelection* theWrappedObject, int i, const QItemSelectionRange& t);
|
|
|
void reserve(QItemSelection* theWrappedObject, int size);
|
|
|
void select(QItemSelection* theWrappedObject, const QModelIndex& topLeft, const QModelIndex& bottomRight);
|
|
|
void setSharable(QItemSelection* theWrappedObject, bool sharable);
|
|
|
int size(QItemSelection* theWrappedObject) const;
|
|
|
void static_QItemSelection_split(const QItemSelectionRange& range, const QItemSelectionRange& other, QItemSelection* result);
|
|
|
bool startsWith(QItemSelection* theWrappedObject, const QItemSelectionRange& t) const;
|
|
|
void swap(QItemSelection* theWrappedObject, QList<QItemSelectionRange >& other);
|
|
|
void swap(QItemSelection* theWrappedObject, int i, int j);
|
|
|
QItemSelectionRange takeAt(QItemSelection* theWrappedObject, int i);
|
|
|
QItemSelectionRange takeFirst(QItemSelection* theWrappedObject);
|
|
|
QItemSelectionRange takeLast(QItemSelection* theWrappedObject);
|
|
|
QVector<QItemSelectionRange > toVector(QItemSelection* theWrappedObject) const;
|
|
|
QItemSelectionRange value(QItemSelection* theWrappedObject, int i) const;
|
|
|
QItemSelectionRange value(QItemSelection* theWrappedObject, int i, const QItemSelectionRange& defaultValue) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QItemSelectionModel : public QItemSelectionModel
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QItemSelectionModel(QAbstractItemModel* model):QItemSelectionModel(model),_wrapper(NULL) {};
|
|
|
PythonQtShell_QItemSelectionModel(QAbstractItemModel* model, QObject* parent):QItemSelectionModel(model, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QItemSelectionModel();
|
|
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void clear();
|
|
|
virtual void clearCurrentIndex();
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void reset();
|
|
|
virtual void select(const QItemSelection& selection, QItemSelectionModel::SelectionFlags command);
|
|
|
virtual void select(const QModelIndex& index, QItemSelectionModel::SelectionFlags command);
|
|
|
virtual void setCurrentIndex(const QModelIndex& index, QItemSelectionModel::SelectionFlags command);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QItemSelectionModel : public QItemSelectionModel
|
|
|
{ public:
|
|
|
inline void promoted_clear() { QItemSelectionModel::clear(); }
|
|
|
inline void promoted_clearCurrentIndex() { QItemSelectionModel::clearCurrentIndex(); }
|
|
|
inline void promoted_reset() { QItemSelectionModel::reset(); }
|
|
|
inline void promoted_select(const QItemSelection& selection, QItemSelectionModel::SelectionFlags command) { QItemSelectionModel::select(selection, command); }
|
|
|
inline void promoted_select(const QModelIndex& index, QItemSelectionModel::SelectionFlags command) { QItemSelectionModel::select(index, command); }
|
|
|
inline void promoted_setCurrentIndex(const QModelIndex& index, QItemSelectionModel::SelectionFlags command) { QItemSelectionModel::setCurrentIndex(index, command); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QItemSelectionModel : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(SelectionFlag )
|
|
|
Q_FLAGS(SelectionFlags )
|
|
|
enum SelectionFlag{
|
|
|
NoUpdate = QItemSelectionModel::NoUpdate, Clear = QItemSelectionModel::Clear, Select = QItemSelectionModel::Select, Deselect = QItemSelectionModel::Deselect, Toggle = QItemSelectionModel::Toggle, Current = QItemSelectionModel::Current, Rows = QItemSelectionModel::Rows, Columns = QItemSelectionModel::Columns, SelectCurrent = QItemSelectionModel::SelectCurrent, ToggleCurrent = QItemSelectionModel::ToggleCurrent, ClearAndSelect = QItemSelectionModel::ClearAndSelect};
|
|
|
Q_DECLARE_FLAGS(SelectionFlags, SelectionFlag)
|
|
|
public slots:
|
|
|
QItemSelectionModel* new_QItemSelectionModel(QAbstractItemModel* model);
|
|
|
QItemSelectionModel* new_QItemSelectionModel(QAbstractItemModel* model, QObject* parent);
|
|
|
void delete_QItemSelectionModel(QItemSelectionModel* obj) { delete obj; }
|
|
|
void clear(QItemSelectionModel* theWrappedObject);
|
|
|
void clearCurrentIndex(QItemSelectionModel* theWrappedObject);
|
|
|
bool columnIntersectsSelection(QItemSelectionModel* theWrappedObject, int column, const QModelIndex& parent) const;
|
|
|
QModelIndex currentIndex(QItemSelectionModel* theWrappedObject) const;
|
|
|
bool hasSelection(QItemSelectionModel* theWrappedObject) const;
|
|
|
bool isColumnSelected(QItemSelectionModel* theWrappedObject, int column, const QModelIndex& parent) const;
|
|
|
bool isRowSelected(QItemSelectionModel* theWrappedObject, int row, const QModelIndex& parent) const;
|
|
|
bool isSelected(QItemSelectionModel* theWrappedObject, const QModelIndex& index) const;
|
|
|
const QAbstractItemModel* model(QItemSelectionModel* theWrappedObject) const;
|
|
|
void reset(QItemSelectionModel* theWrappedObject);
|
|
|
bool rowIntersectsSelection(QItemSelectionModel* theWrappedObject, int row, const QModelIndex& parent) const;
|
|
|
void select(QItemSelectionModel* theWrappedObject, const QItemSelection& selection, QItemSelectionModel::SelectionFlags command);
|
|
|
void select(QItemSelectionModel* theWrappedObject, const QModelIndex& index, QItemSelectionModel::SelectionFlags command);
|
|
|
QList<QModelIndex > selectedColumns(QItemSelectionModel* theWrappedObject, int row = 0) const;
|
|
|
QList<QModelIndex > selectedIndexes(QItemSelectionModel* theWrappedObject) const;
|
|
|
QList<QModelIndex > selectedRows(QItemSelectionModel* theWrappedObject, int column = 0) const;
|
|
|
const QItemSelection selection(QItemSelectionModel* theWrappedObject) const;
|
|
|
void setCurrentIndex(QItemSelectionModel* theWrappedObject, const QModelIndex& index, QItemSelectionModel::SelectionFlags command);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QItemSelectionRange : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QItemSelectionRange* new_QItemSelectionRange();
|
|
|
QItemSelectionRange* new_QItemSelectionRange(const QItemSelectionRange& other);
|
|
|
QItemSelectionRange* new_QItemSelectionRange(const QModelIndex& index);
|
|
|
QItemSelectionRange* new_QItemSelectionRange(const QModelIndex& topLeft, const QModelIndex& bottomRight);
|
|
|
void delete_QItemSelectionRange(QItemSelectionRange* obj) { delete obj; }
|
|
|
int bottom(QItemSelectionRange* theWrappedObject) const;
|
|
|
const QPersistentModelIndex* bottomRight(QItemSelectionRange* theWrappedObject) const;
|
|
|
bool contains(QItemSelectionRange* theWrappedObject, const QModelIndex& index) const;
|
|
|
bool contains(QItemSelectionRange* theWrappedObject, int row, int column, const QModelIndex& parentIndex) const;
|
|
|
int height(QItemSelectionRange* theWrappedObject) const;
|
|
|
QList<QModelIndex > indexes(QItemSelectionRange* theWrappedObject) const;
|
|
|
QItemSelectionRange intersected(QItemSelectionRange* theWrappedObject, const QItemSelectionRange& other) const;
|
|
|
bool intersects(QItemSelectionRange* theWrappedObject, const QItemSelectionRange& other) const;
|
|
|
bool isEmpty(QItemSelectionRange* theWrappedObject) const;
|
|
|
bool isValid(QItemSelectionRange* theWrappedObject) const;
|
|
|
int left(QItemSelectionRange* theWrappedObject) const;
|
|
|
const QAbstractItemModel* model(QItemSelectionRange* theWrappedObject) const;
|
|
|
bool __ne__(QItemSelectionRange* theWrappedObject, const QItemSelectionRange& other) const;
|
|
|
bool __lt__(QItemSelectionRange* theWrappedObject, const QItemSelectionRange& other) const;
|
|
|
bool __eq__(QItemSelectionRange* theWrappedObject, const QItemSelectionRange& other) const;
|
|
|
QModelIndex parent(QItemSelectionRange* theWrappedObject) const;
|
|
|
int right(QItemSelectionRange* theWrappedObject) const;
|
|
|
int top(QItemSelectionRange* theWrappedObject) const;
|
|
|
const QPersistentModelIndex* topLeft(QItemSelectionRange* theWrappedObject) const;
|
|
|
int width(QItemSelectionRange* theWrappedObject) const;
|
|
|
QString py_toString(QItemSelectionRange*);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QKeyEvent : public QKeyEvent
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QKeyEvent(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text = QString(), bool autorep = false, ushort count = 1):QKeyEvent(type, key, modifiers, text, autorep, count),_wrapper(NULL) {};
|
|
|
PythonQtShell_QKeyEvent(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, unsigned int nativeScanCode, unsigned int nativeVirtualKey, unsigned int nativeModifiers, const QString& text = QString(), bool autorep = false, ushort count = 1):QKeyEvent(type, key, modifiers, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QKeyEvent();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QKeyEvent : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QKeyEvent* new_QKeyEvent(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text = QString(), bool autorep = false, ushort count = 1);
|
|
|
QKeyEvent* new_QKeyEvent(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, unsigned int nativeScanCode, unsigned int nativeVirtualKey, unsigned int nativeModifiers, const QString& text = QString(), bool autorep = false, ushort count = 1);
|
|
|
void delete_QKeyEvent(QKeyEvent* obj) { delete obj; }
|
|
|
int count(QKeyEvent* theWrappedObject) const;
|
|
|
bool isAutoRepeat(QKeyEvent* theWrappedObject) const;
|
|
|
int key(QKeyEvent* theWrappedObject) const;
|
|
|
bool matches(QKeyEvent* theWrappedObject, QKeySequence::StandardKey key) const;
|
|
|
Qt::KeyboardModifiers modifiers(QKeyEvent* theWrappedObject) const;
|
|
|
unsigned int nativeModifiers(QKeyEvent* theWrappedObject) const;
|
|
|
unsigned int nativeScanCode(QKeyEvent* theWrappedObject) const;
|
|
|
unsigned int nativeVirtualKey(QKeyEvent* theWrappedObject) const;
|
|
|
QString text(QKeyEvent* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QKeyEventTransition : public QKeyEventTransition
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QKeyEventTransition(QObject* object, QEvent::Type type, int key, QState* sourceState = 0):QKeyEventTransition(object, type, key, sourceState),_wrapper(NULL) {};
|
|
|
PythonQtShell_QKeyEventTransition(QState* sourceState = 0):QKeyEventTransition(sourceState),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QKeyEventTransition();
|
|
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* e);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual bool eventTest(QEvent* event);
|
|
|
virtual void onTransition(QEvent* event);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QKeyEventTransition : public QKeyEventTransition
|
|
|
{ public:
|
|
|
inline bool promoted_eventTest(QEvent* event) { return QKeyEventTransition::eventTest(event); }
|
|
|
inline void promoted_onTransition(QEvent* event) { QKeyEventTransition::onTransition(event); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QKeyEventTransition : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QKeyEventTransition* new_QKeyEventTransition(QObject* object, QEvent::Type type, int key, QState* sourceState = 0);
|
|
|
QKeyEventTransition* new_QKeyEventTransition(QState* sourceState = 0);
|
|
|
void delete_QKeyEventTransition(QKeyEventTransition* obj) { delete obj; }
|
|
|
bool eventTest(QKeyEventTransition* theWrappedObject, QEvent* event);
|
|
|
int key(QKeyEventTransition* theWrappedObject) const;
|
|
|
Qt::KeyboardModifiers modifierMask(QKeyEventTransition* theWrappedObject) const;
|
|
|
void onTransition(QKeyEventTransition* theWrappedObject, QEvent* event);
|
|
|
void setKey(QKeyEventTransition* theWrappedObject, int key);
|
|
|
void setModifierMask(QKeyEventTransition* theWrappedObject, Qt::KeyboardModifiers modifiers);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
