com_trolltech_qt_gui3.h
2006 lines
| 109.6 KiB
| text/x-c
|
CLexer
Orochimarufan
|
r205 | #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); | ||||
}; | ||||