|
|
#include <PythonQt.h>
|
|
|
#include <QIcon>
|
|
|
#include <QObject>
|
|
|
#include <QTextBlock>
|
|
|
#include <QTextCursor>
|
|
|
#include <QTextDocumentFragment>
|
|
|
#include <QTextEdit>
|
|
|
#include <QTextFormat>
|
|
|
#include <QTextFrame>
|
|
|
#include <QVariant>
|
|
|
#include <qabstractitemdelegate.h>
|
|
|
#include <qabstractitemmodel.h>
|
|
|
#include <qabstractitemview.h>
|
|
|
#include <qaction.h>
|
|
|
#include <qbitmap.h>
|
|
|
#include <qbrush.h>
|
|
|
#include <qbytearray.h>
|
|
|
#include <qcolor.h>
|
|
|
#include <qcoreevent.h>
|
|
|
#include <qcursor.h>
|
|
|
#include <qdatastream.h>
|
|
|
#include <qevent.h>
|
|
|
#include <qfont.h>
|
|
|
#include <qgesture.h>
|
|
|
#include <qgraphicseffect.h>
|
|
|
#include <qgraphicsproxywidget.h>
|
|
|
#include <qheaderview.h>
|
|
|
#include <qicon.h>
|
|
|
#include <qimage.h>
|
|
|
#include <qinputcontext.h>
|
|
|
#include <qiodevice.h>
|
|
|
#include <qitemeditorfactory.h>
|
|
|
#include <qitemselectionmodel.h>
|
|
|
#include <qkeysequence.h>
|
|
|
#include <qlayout.h>
|
|
|
#include <qlist.h>
|
|
|
#include <qlocale.h>
|
|
|
#include <qmargins.h>
|
|
|
#include <qmenu.h>
|
|
|
#include <qmimedata.h>
|
|
|
#include <qobject.h>
|
|
|
#include <qpaintdevice.h>
|
|
|
#include <qpaintengine.h>
|
|
|
#include <qpainter.h>
|
|
|
#include <qpalette.h>
|
|
|
#include <qpen.h>
|
|
|
#include <qpoint.h>
|
|
|
#include <qprinter.h>
|
|
|
#include <qrect.h>
|
|
|
#include <qregexp.h>
|
|
|
#include <qregion.h>
|
|
|
#include <qscrollbar.h>
|
|
|
#include <qsize.h>
|
|
|
#include <qsizepolicy.h>
|
|
|
#include <qstringlist.h>
|
|
|
#include <qstyle.h>
|
|
|
#include <qstyleditemdelegate.h>
|
|
|
#include <qstyleoption.h>
|
|
|
#include <qstyleplugin.h>
|
|
|
#include <qsyntaxhighlighter.h>
|
|
|
#include <qsystemtrayicon.h>
|
|
|
#include <qtabbar.h>
|
|
|
#include <qtableview.h>
|
|
|
#include <qtablewidget.h>
|
|
|
#include <qtabwidget.h>
|
|
|
#include <qtextbrowser.h>
|
|
|
#include <qtextcodec.h>
|
|
|
#include <qtextcodecplugin.h>
|
|
|
#include <qtextcursor.h>
|
|
|
#include <qtextdocument.h>
|
|
|
#include <qtextdocumentfragment.h>
|
|
|
#include <qtextdocumentwriter.h>
|
|
|
#include <qtextedit.h>
|
|
|
#include <qtextformat.h>
|
|
|
#include <qtextlayout.h>
|
|
|
#include <qtextlist.h>
|
|
|
#include <qtextobject.h>
|
|
|
#include <qtextoption.h>
|
|
|
#include <qtexttable.h>
|
|
|
#include <qurl.h>
|
|
|
#include <qvector.h>
|
|
|
#include <qwidget.h>
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QStylePlugin : public QStylePlugin
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QStylePlugin(QObject* parent = 0):QStylePlugin(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QStylePlugin();
|
|
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual QStyle* create(const QString& key);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual QStringList keys() const;
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QStylePlugin : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QStylePlugin* new_QStylePlugin(QObject* parent = 0);
|
|
|
void delete_QStylePlugin(QStylePlugin* obj) { delete obj; }
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QStyledItemDelegate : public QStyledItemDelegate
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QStyledItemDelegate(QObject* parent = 0):QStyledItemDelegate(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QStyledItemDelegate();
|
|
|
|
|
|
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 QString displayText(const QVariant& value, const QLocale& locale) 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 void initStyleOption(QStyleOptionViewItem* option, const QModelIndex& index) const;
|
|
|
virtual void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) 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_QStyledItemDelegate : public QStyledItemDelegate
|
|
|
{ public:
|
|
|
inline QWidget* promoted_createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const { return QStyledItemDelegate::createEditor(parent, option, index); }
|
|
|
inline QString promoted_displayText(const QVariant& value, const QLocale& locale) const { return QStyledItemDelegate::displayText(value, locale); }
|
|
|
inline bool promoted_editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index) { return QStyledItemDelegate::editorEvent(event, model, option, index); }
|
|
|
inline bool promoted_eventFilter(QObject* object, QEvent* event) { return QStyledItemDelegate::eventFilter(object, event); }
|
|
|
inline void promoted_initStyleOption(QStyleOptionViewItem* option, const QModelIndex& index) const { QStyledItemDelegate::initStyleOption(option, index); }
|
|
|
inline void promoted_paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const { QStyledItemDelegate::paint(painter, option, index); }
|
|
|
inline void promoted_setEditorData(QWidget* editor, const QModelIndex& index) const { QStyledItemDelegate::setEditorData(editor, index); }
|
|
|
inline void promoted_setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const { QStyledItemDelegate::setModelData(editor, model, index); }
|
|
|
inline QSize promoted_sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const { return QStyledItemDelegate::sizeHint(option, index); }
|
|
|
inline void promoted_updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const { QStyledItemDelegate::updateEditorGeometry(editor, option, index); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QStyledItemDelegate : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QStyledItemDelegate* new_QStyledItemDelegate(QObject* parent = 0);
|
|
|
void delete_QStyledItemDelegate(QStyledItemDelegate* obj) { delete obj; }
|
|
|
QWidget* createEditor(QStyledItemDelegate* theWrappedObject, QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const;
|
|
|
QString displayText(QStyledItemDelegate* theWrappedObject, const QVariant& value, const QLocale& locale) const;
|
|
|
bool editorEvent(QStyledItemDelegate* theWrappedObject, QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index);
|
|
|
bool eventFilter(QStyledItemDelegate* theWrappedObject, QObject* object, QEvent* event);
|
|
|
void initStyleOption(QStyledItemDelegate* theWrappedObject, QStyleOptionViewItem* option, const QModelIndex& index) const;
|
|
|
QItemEditorFactory* itemEditorFactory(QStyledItemDelegate* theWrappedObject) const;
|
|
|
void paint(QStyledItemDelegate* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const;
|
|
|
void setEditorData(QStyledItemDelegate* theWrappedObject, QWidget* editor, const QModelIndex& index) const;
|
|
|
void setItemEditorFactory(QStyledItemDelegate* theWrappedObject, QItemEditorFactory* factory);
|
|
|
void setModelData(QStyledItemDelegate* theWrappedObject, QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const;
|
|
|
QSize sizeHint(QStyledItemDelegate* theWrappedObject, const QStyleOptionViewItem& option, const QModelIndex& index) const;
|
|
|
void updateEditorGeometry(QStyledItemDelegate* theWrappedObject, QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QSwipeGesture : public QSwipeGesture
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QSwipeGesture(QObject* parent = 0):QSwipeGesture(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QSwipeGesture();
|
|
|
|
|
|
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_QSwipeGesture : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QSwipeGesture* new_QSwipeGesture(QObject* parent = 0);
|
|
|
void delete_QSwipeGesture(QSwipeGesture* obj) { delete obj; }
|
|
|
QSwipeGesture::SwipeDirection horizontalDirection(QSwipeGesture* theWrappedObject) const;
|
|
|
void setSwipeAngle(QSwipeGesture* theWrappedObject, qreal value);
|
|
|
qreal swipeAngle(QSwipeGesture* theWrappedObject) const;
|
|
|
QSwipeGesture::SwipeDirection verticalDirection(QSwipeGesture* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QSyntaxHighlighter : public QSyntaxHighlighter
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QSyntaxHighlighter(QObject* parent):QSyntaxHighlighter(parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QSyntaxHighlighter(QTextDocument* parent):QSyntaxHighlighter(parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QSyntaxHighlighter(QTextEdit* parent):QSyntaxHighlighter(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QSyntaxHighlighter();
|
|
|
|
|
|
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 highlightBlock(const QString& text);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QSyntaxHighlighter : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QSyntaxHighlighter* new_QSyntaxHighlighter(QObject* parent);
|
|
|
QSyntaxHighlighter* new_QSyntaxHighlighter(QTextDocument* parent);
|
|
|
QSyntaxHighlighter* new_QSyntaxHighlighter(QTextEdit* parent);
|
|
|
void delete_QSyntaxHighlighter(QSyntaxHighlighter* obj) { delete obj; }
|
|
|
QTextDocument* document(QSyntaxHighlighter* theWrappedObject) const;
|
|
|
void setDocument(QSyntaxHighlighter* theWrappedObject, QTextDocument* doc);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QSystemTrayIcon : public QSystemTrayIcon
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QSystemTrayIcon(QObject* parent = 0):QSystemTrayIcon(parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QSystemTrayIcon(const QIcon& icon, QObject* parent = 0):QSystemTrayIcon(icon, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QSystemTrayIcon();
|
|
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* event);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QSystemTrayIcon : public QSystemTrayIcon
|
|
|
{ public:
|
|
|
inline bool promoted_event(QEvent* event) { return QSystemTrayIcon::event(event); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QSystemTrayIcon : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(MessageIcon ActivationReason )
|
|
|
enum MessageIcon{
|
|
|
NoIcon = QSystemTrayIcon::NoIcon, Information = QSystemTrayIcon::Information, Warning = QSystemTrayIcon::Warning, Critical = QSystemTrayIcon::Critical};
|
|
|
enum ActivationReason{
|
|
|
Unknown = QSystemTrayIcon::Unknown, Context = QSystemTrayIcon::Context, DoubleClick = QSystemTrayIcon::DoubleClick, Trigger = QSystemTrayIcon::Trigger, MiddleClick = QSystemTrayIcon::MiddleClick};
|
|
|
public slots:
|
|
|
QSystemTrayIcon* new_QSystemTrayIcon(QObject* parent = 0);
|
|
|
QSystemTrayIcon* new_QSystemTrayIcon(const QIcon& icon, QObject* parent = 0);
|
|
|
void delete_QSystemTrayIcon(QSystemTrayIcon* obj) { delete obj; }
|
|
|
QMenu* contextMenu(QSystemTrayIcon* theWrappedObject) const;
|
|
|
bool event(QSystemTrayIcon* theWrappedObject, QEvent* event);
|
|
|
QRect geometry(QSystemTrayIcon* theWrappedObject) const;
|
|
|
QIcon icon(QSystemTrayIcon* theWrappedObject) const;
|
|
|
bool static_QSystemTrayIcon_isSystemTrayAvailable();
|
|
|
bool isVisible(QSystemTrayIcon* theWrappedObject) const;
|
|
|
void setContextMenu(QSystemTrayIcon* theWrappedObject, QMenu* menu);
|
|
|
void setIcon(QSystemTrayIcon* theWrappedObject, const QIcon& icon);
|
|
|
void setToolTip(QSystemTrayIcon* theWrappedObject, const QString& tip);
|
|
|
void showMessage(QSystemTrayIcon* theWrappedObject, const QString& title, const QString& msg, QSystemTrayIcon::MessageIcon icon = QSystemTrayIcon::Information, int msecs = 10000);
|
|
|
bool static_QSystemTrayIcon_supportsMessages();
|
|
|
QString toolTip(QSystemTrayIcon* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTabBar : public QTabBar
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTabBar(QWidget* parent = 0):QTabBar(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTabBar();
|
|
|
|
|
|
virtual void actionEvent(QActionEvent* arg__1);
|
|
|
virtual void changeEvent(QEvent* arg__1);
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void closeEvent(QCloseEvent* arg__1);
|
|
|
virtual void contextMenuEvent(QContextMenuEvent* arg__1);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual int devType() const;
|
|
|
virtual void dragEnterEvent(QDragEnterEvent* arg__1);
|
|
|
virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
|
|
|
virtual void dragMoveEvent(QDragMoveEvent* arg__1);
|
|
|
virtual void dropEvent(QDropEvent* arg__1);
|
|
|
virtual void enterEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void focusInEvent(QFocusEvent* arg__1);
|
|
|
virtual bool focusNextPrevChild(bool next);
|
|
|
virtual void focusOutEvent(QFocusEvent* arg__1);
|
|
|
virtual int heightForWidth(int arg__1) const;
|
|
|
virtual void hideEvent(QHideEvent* arg__1);
|
|
|
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 languageChange();
|
|
|
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 QPaintEngine* paintEngine() const;
|
|
|
virtual void paintEvent(QPaintEvent* arg__1);
|
|
|
virtual void resizeEvent(QResizeEvent* arg__1);
|
|
|
virtual void showEvent(QShowEvent* arg__1);
|
|
|
virtual void tabInserted(int index);
|
|
|
virtual void tabLayoutChange();
|
|
|
virtual void tabRemoved(int index);
|
|
|
virtual QSize tabSizeHint(int index) const;
|
|
|
virtual void tabletEvent(QTabletEvent* arg__1);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
virtual void wheelEvent(QWheelEvent* event);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTabBar : public QTabBar
|
|
|
{ public:
|
|
|
inline void promoted_changeEvent(QEvent* arg__1) { QTabBar::changeEvent(arg__1); }
|
|
|
inline bool promoted_event(QEvent* arg__1) { return QTabBar::event(arg__1); }
|
|
|
inline void promoted_hideEvent(QHideEvent* arg__1) { QTabBar::hideEvent(arg__1); }
|
|
|
inline void promoted_keyPressEvent(QKeyEvent* arg__1) { QTabBar::keyPressEvent(arg__1); }
|
|
|
inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { QTabBar::mouseMoveEvent(arg__1); }
|
|
|
inline void promoted_mousePressEvent(QMouseEvent* arg__1) { QTabBar::mousePressEvent(arg__1); }
|
|
|
inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { QTabBar::mouseReleaseEvent(arg__1); }
|
|
|
inline void promoted_paintEvent(QPaintEvent* arg__1) { QTabBar::paintEvent(arg__1); }
|
|
|
inline void promoted_resizeEvent(QResizeEvent* arg__1) { QTabBar::resizeEvent(arg__1); }
|
|
|
inline void promoted_showEvent(QShowEvent* arg__1) { QTabBar::showEvent(arg__1); }
|
|
|
inline void promoted_tabInserted(int index) { QTabBar::tabInserted(index); }
|
|
|
inline void promoted_tabLayoutChange() { QTabBar::tabLayoutChange(); }
|
|
|
inline void promoted_tabRemoved(int index) { QTabBar::tabRemoved(index); }
|
|
|
inline QSize promoted_tabSizeHint(int index) const { return QTabBar::tabSizeHint(index); }
|
|
|
inline void promoted_wheelEvent(QWheelEvent* event) { QTabBar::wheelEvent(event); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTabBar : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(SelectionBehavior ButtonPosition )
|
|
|
enum SelectionBehavior{
|
|
|
SelectLeftTab = QTabBar::SelectLeftTab, SelectRightTab = QTabBar::SelectRightTab, SelectPreviousTab = QTabBar::SelectPreviousTab};
|
|
|
enum ButtonPosition{
|
|
|
LeftSide = QTabBar::LeftSide, RightSide = QTabBar::RightSide};
|
|
|
public slots:
|
|
|
QTabBar* new_QTabBar(QWidget* parent = 0);
|
|
|
void delete_QTabBar(QTabBar* obj) { delete obj; }
|
|
|
int addTab(QTabBar* theWrappedObject, const QIcon& icon, const QString& text);
|
|
|
int addTab(QTabBar* theWrappedObject, const QString& text);
|
|
|
void changeEvent(QTabBar* theWrappedObject, QEvent* arg__1);
|
|
|
int count(QTabBar* theWrappedObject) const;
|
|
|
int currentIndex(QTabBar* theWrappedObject) const;
|
|
|
bool documentMode(QTabBar* theWrappedObject) const;
|
|
|
bool drawBase(QTabBar* theWrappedObject) const;
|
|
|
Qt::TextElideMode elideMode(QTabBar* theWrappedObject) const;
|
|
|
bool event(QTabBar* theWrappedObject, QEvent* arg__1);
|
|
|
bool expanding(QTabBar* theWrappedObject) const;
|
|
|
void hideEvent(QTabBar* theWrappedObject, QHideEvent* arg__1);
|
|
|
QSize iconSize(QTabBar* theWrappedObject) const;
|
|
|
int insertTab(QTabBar* theWrappedObject, int index, const QIcon& icon, const QString& text);
|
|
|
int insertTab(QTabBar* theWrappedObject, int index, const QString& text);
|
|
|
bool isMovable(QTabBar* theWrappedObject) const;
|
|
|
bool isTabEnabled(QTabBar* theWrappedObject, int index) const;
|
|
|
void keyPressEvent(QTabBar* theWrappedObject, QKeyEvent* arg__1);
|
|
|
QSize minimumSizeHint(QTabBar* theWrappedObject) const;
|
|
|
void mouseMoveEvent(QTabBar* theWrappedObject, QMouseEvent* arg__1);
|
|
|
void mousePressEvent(QTabBar* theWrappedObject, QMouseEvent* arg__1);
|
|
|
void mouseReleaseEvent(QTabBar* theWrappedObject, QMouseEvent* arg__1);
|
|
|
void moveTab(QTabBar* theWrappedObject, int from, int to);
|
|
|
void paintEvent(QTabBar* theWrappedObject, QPaintEvent* arg__1);
|
|
|
void removeTab(QTabBar* theWrappedObject, int index);
|
|
|
void resizeEvent(QTabBar* theWrappedObject, QResizeEvent* arg__1);
|
|
|
QTabBar::SelectionBehavior selectionBehaviorOnRemove(QTabBar* theWrappedObject) const;
|
|
|
void setDocumentMode(QTabBar* theWrappedObject, bool set);
|
|
|
void setDrawBase(QTabBar* theWrappedObject, bool drawTheBase);
|
|
|
void setElideMode(QTabBar* theWrappedObject, Qt::TextElideMode arg__1);
|
|
|
void setExpanding(QTabBar* theWrappedObject, bool enabled);
|
|
|
void setIconSize(QTabBar* theWrappedObject, const QSize& size);
|
|
|
void setMovable(QTabBar* theWrappedObject, bool movable);
|
|
|
void setSelectionBehaviorOnRemove(QTabBar* theWrappedObject, QTabBar::SelectionBehavior behavior);
|
|
|
void setShape(QTabBar* theWrappedObject, QTabBar::Shape shape);
|
|
|
void setTabButton(QTabBar* theWrappedObject, int index, QTabBar::ButtonPosition position, QWidget* widget);
|
|
|
void setTabData(QTabBar* theWrappedObject, int index, const QVariant& data);
|
|
|
void setTabEnabled(QTabBar* theWrappedObject, int index, bool arg__2);
|
|
|
void setTabIcon(QTabBar* theWrappedObject, int index, const QIcon& icon);
|
|
|
void setTabText(QTabBar* theWrappedObject, int index, const QString& text);
|
|
|
void setTabTextColor(QTabBar* theWrappedObject, int index, const QColor& color);
|
|
|
void setTabToolTip(QTabBar* theWrappedObject, int index, const QString& tip);
|
|
|
void setTabWhatsThis(QTabBar* theWrappedObject, int index, const QString& text);
|
|
|
void setTabsClosable(QTabBar* theWrappedObject, bool closable);
|
|
|
void setUsesScrollButtons(QTabBar* theWrappedObject, bool useButtons);
|
|
|
QTabBar::Shape shape(QTabBar* theWrappedObject) const;
|
|
|
void showEvent(QTabBar* theWrappedObject, QShowEvent* arg__1);
|
|
|
QSize sizeHint(QTabBar* theWrappedObject) const;
|
|
|
int tabAt(QTabBar* theWrappedObject, const QPoint& pos) const;
|
|
|
QWidget* tabButton(QTabBar* theWrappedObject, int index, QTabBar::ButtonPosition position) const;
|
|
|
QVariant tabData(QTabBar* theWrappedObject, int index) const;
|
|
|
QIcon tabIcon(QTabBar* theWrappedObject, int index) const;
|
|
|
void tabInserted(QTabBar* theWrappedObject, int index);
|
|
|
void tabLayoutChange(QTabBar* theWrappedObject);
|
|
|
QRect tabRect(QTabBar* theWrappedObject, int index) const;
|
|
|
void tabRemoved(QTabBar* theWrappedObject, int index);
|
|
|
QSize tabSizeHint(QTabBar* theWrappedObject, int index) const;
|
|
|
QString tabText(QTabBar* theWrappedObject, int index) const;
|
|
|
QColor tabTextColor(QTabBar* theWrappedObject, int index) const;
|
|
|
QString tabToolTip(QTabBar* theWrappedObject, int index) const;
|
|
|
QString tabWhatsThis(QTabBar* theWrappedObject, int index) const;
|
|
|
bool tabsClosable(QTabBar* theWrappedObject) const;
|
|
|
bool usesScrollButtons(QTabBar* theWrappedObject) const;
|
|
|
void wheelEvent(QTabBar* theWrappedObject, QWheelEvent* event);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTabWidget : public QTabWidget
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTabWidget(QWidget* parent = 0):QTabWidget(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTabWidget();
|
|
|
|
|
|
virtual void actionEvent(QActionEvent* arg__1);
|
|
|
virtual void changeEvent(QEvent* arg__1);
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void closeEvent(QCloseEvent* arg__1);
|
|
|
virtual void contextMenuEvent(QContextMenuEvent* arg__1);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual int devType() const;
|
|
|
virtual void dragEnterEvent(QDragEnterEvent* arg__1);
|
|
|
virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
|
|
|
virtual void dragMoveEvent(QDragMoveEvent* arg__1);
|
|
|
virtual void dropEvent(QDropEvent* arg__1);
|
|
|
virtual void enterEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void focusInEvent(QFocusEvent* arg__1);
|
|
|
virtual bool focusNextPrevChild(bool next);
|
|
|
virtual void focusOutEvent(QFocusEvent* arg__1);
|
|
|
virtual int heightForWidth(int width) const;
|
|
|
virtual void hideEvent(QHideEvent* arg__1);
|
|
|
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 languageChange();
|
|
|
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 QPaintEngine* paintEngine() const;
|
|
|
virtual void paintEvent(QPaintEvent* arg__1);
|
|
|
virtual void resizeEvent(QResizeEvent* arg__1);
|
|
|
virtual void showEvent(QShowEvent* arg__1);
|
|
|
virtual void tabInserted(int index);
|
|
|
virtual void tabRemoved(int index);
|
|
|
virtual void tabletEvent(QTabletEvent* arg__1);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
virtual void wheelEvent(QWheelEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTabWidget : public QTabWidget
|
|
|
{ public:
|
|
|
inline void promoted_changeEvent(QEvent* arg__1) { QTabWidget::changeEvent(arg__1); }
|
|
|
inline bool promoted_event(QEvent* arg__1) { return QTabWidget::event(arg__1); }
|
|
|
inline int promoted_heightForWidth(int width) const { return QTabWidget::heightForWidth(width); }
|
|
|
inline void promoted_keyPressEvent(QKeyEvent* arg__1) { QTabWidget::keyPressEvent(arg__1); }
|
|
|
inline void promoted_paintEvent(QPaintEvent* arg__1) { QTabWidget::paintEvent(arg__1); }
|
|
|
inline void promoted_resizeEvent(QResizeEvent* arg__1) { QTabWidget::resizeEvent(arg__1); }
|
|
|
inline void promoted_showEvent(QShowEvent* arg__1) { QTabWidget::showEvent(arg__1); }
|
|
|
inline void promoted_tabInserted(int index) { QTabWidget::tabInserted(index); }
|
|
|
inline void promoted_tabRemoved(int index) { QTabWidget::tabRemoved(index); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTabWidget : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTabWidget* new_QTabWidget(QWidget* parent = 0);
|
|
|
void delete_QTabWidget(QTabWidget* obj) { delete obj; }
|
|
|
int addTab(QTabWidget* theWrappedObject, QWidget* widget, const QIcon& icon, const QString& label);
|
|
|
int addTab(QTabWidget* theWrappedObject, QWidget* widget, const QString& arg__2);
|
|
|
void changeEvent(QTabWidget* theWrappedObject, QEvent* arg__1);
|
|
|
void clear(QTabWidget* theWrappedObject);
|
|
|
QWidget* cornerWidget(QTabWidget* theWrappedObject, Qt::Corner corner = Qt::TopRightCorner) const;
|
|
|
int count(QTabWidget* theWrappedObject) const;
|
|
|
int currentIndex(QTabWidget* theWrappedObject) const;
|
|
|
QWidget* currentWidget(QTabWidget* theWrappedObject) const;
|
|
|
bool documentMode(QTabWidget* theWrappedObject) const;
|
|
|
Qt::TextElideMode elideMode(QTabWidget* theWrappedObject) const;
|
|
|
bool event(QTabWidget* theWrappedObject, QEvent* arg__1);
|
|
|
int heightForWidth(QTabWidget* theWrappedObject, int width) const;
|
|
|
QSize iconSize(QTabWidget* theWrappedObject) const;
|
|
|
int indexOf(QTabWidget* theWrappedObject, QWidget* widget) const;
|
|
|
int insertTab(QTabWidget* theWrappedObject, int index, QWidget* widget, const QIcon& icon, const QString& label);
|
|
|
int insertTab(QTabWidget* theWrappedObject, int index, QWidget* widget, const QString& arg__3);
|
|
|
bool isMovable(QTabWidget* theWrappedObject) const;
|
|
|
bool isTabEnabled(QTabWidget* theWrappedObject, int index) const;
|
|
|
void keyPressEvent(QTabWidget* theWrappedObject, QKeyEvent* arg__1);
|
|
|
QSize minimumSizeHint(QTabWidget* theWrappedObject) const;
|
|
|
void paintEvent(QTabWidget* theWrappedObject, QPaintEvent* arg__1);
|
|
|
void removeTab(QTabWidget* theWrappedObject, int index);
|
|
|
void resizeEvent(QTabWidget* theWrappedObject, QResizeEvent* arg__1);
|
|
|
void setCornerWidget(QTabWidget* theWrappedObject, QWidget* w, Qt::Corner corner = Qt::TopRightCorner);
|
|
|
void setDocumentMode(QTabWidget* theWrappedObject, bool set);
|
|
|
void setElideMode(QTabWidget* theWrappedObject, Qt::TextElideMode arg__1);
|
|
|
void setIconSize(QTabWidget* theWrappedObject, const QSize& size);
|
|
|
void setMovable(QTabWidget* theWrappedObject, bool movable);
|
|
|
void setTabEnabled(QTabWidget* theWrappedObject, int index, bool arg__2);
|
|
|
void setTabIcon(QTabWidget* theWrappedObject, int index, const QIcon& icon);
|
|
|
void setTabPosition(QTabWidget* theWrappedObject, QTabWidget::TabPosition arg__1);
|
|
|
void setTabShape(QTabWidget* theWrappedObject, QTabWidget::TabShape s);
|
|
|
void setTabText(QTabWidget* theWrappedObject, int index, const QString& arg__2);
|
|
|
void setTabToolTip(QTabWidget* theWrappedObject, int index, const QString& tip);
|
|
|
void setTabWhatsThis(QTabWidget* theWrappedObject, int index, const QString& text);
|
|
|
void setTabsClosable(QTabWidget* theWrappedObject, bool closeable);
|
|
|
void setUsesScrollButtons(QTabWidget* theWrappedObject, bool useButtons);
|
|
|
void showEvent(QTabWidget* theWrappedObject, QShowEvent* arg__1);
|
|
|
QSize sizeHint(QTabWidget* theWrappedObject) const;
|
|
|
QIcon tabIcon(QTabWidget* theWrappedObject, int index) const;
|
|
|
void tabInserted(QTabWidget* theWrappedObject, int index);
|
|
|
QTabWidget::TabPosition tabPosition(QTabWidget* theWrappedObject) const;
|
|
|
void tabRemoved(QTabWidget* theWrappedObject, int index);
|
|
|
QTabWidget::TabShape tabShape(QTabWidget* theWrappedObject) const;
|
|
|
QString tabText(QTabWidget* theWrappedObject, int index) const;
|
|
|
QString tabToolTip(QTabWidget* theWrappedObject, int index) const;
|
|
|
QString tabWhatsThis(QTabWidget* theWrappedObject, int index) const;
|
|
|
bool tabsClosable(QTabWidget* theWrappedObject) const;
|
|
|
bool usesScrollButtons(QTabWidget* theWrappedObject) const;
|
|
|
QWidget* widget(QTabWidget* theWrappedObject, int index) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTableView : public QTableView
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTableView(QWidget* parent = 0):QTableView(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTableView();
|
|
|
|
|
|
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& previous);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual void dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight);
|
|
|
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* 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 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 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 languageChange();
|
|
|
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 QPaintEngine* paintEngine() const;
|
|
|
virtual void paintEvent(QPaintEvent* e);
|
|
|
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 = QAbstractItemView::EnsureVisible);
|
|
|
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 command);
|
|
|
virtual void setSelectionModel(QItemSelectionModel* selectionModel);
|
|
|
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* event);
|
|
|
virtual QRect visualRect(const QModelIndex& index) const;
|
|
|
virtual QRegion visualRegionForSelection(const QItemSelection& selection) const;
|
|
|
virtual void wheelEvent(QWheelEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTableView : public QTableView
|
|
|
{ public:
|
|
|
inline void promoted_currentChanged(const QModelIndex& current, const QModelIndex& previous) { QTableView::currentChanged(current, previous); }
|
|
|
inline void promoted_doItemsLayout() { QTableView::doItemsLayout(); }
|
|
|
inline int promoted_horizontalOffset() const { return QTableView::horizontalOffset(); }
|
|
|
inline void promoted_horizontalScrollbarAction(int action) { QTableView::horizontalScrollbarAction(action); }
|
|
|
inline QModelIndex promoted_indexAt(const QPoint& p) const { return QTableView::indexAt(p); }
|
|
|
inline bool promoted_isIndexHidden(const QModelIndex& index) const { return QTableView::isIndexHidden(index); }
|
|
|
inline void promoted_paintEvent(QPaintEvent* e) { QTableView::paintEvent(e); }
|
|
|
inline void promoted_scrollContentsBy(int dx, int dy) { QTableView::scrollContentsBy(dx, dy); }
|
|
|
inline void promoted_scrollTo(const QModelIndex& index, QAbstractItemView::ScrollHint hint = QAbstractItemView::EnsureVisible) { QTableView::scrollTo(index, hint); }
|
|
|
inline QList<QModelIndex > promoted_selectedIndexes() const { return QTableView::selectedIndexes(); }
|
|
|
inline void promoted_selectionChanged(const QItemSelection& selected, const QItemSelection& deselected) { QTableView::selectionChanged(selected, deselected); }
|
|
|
inline void promoted_setModel(QAbstractItemModel* model) { QTableView::setModel(model); }
|
|
|
inline void promoted_setRootIndex(const QModelIndex& index) { QTableView::setRootIndex(index); }
|
|
|
inline void promoted_setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags command) { QTableView::setSelection(rect, command); }
|
|
|
inline void promoted_setSelectionModel(QItemSelectionModel* selectionModel) { QTableView::setSelectionModel(selectionModel); }
|
|
|
inline int promoted_sizeHintForColumn(int column) const { return QTableView::sizeHintForColumn(column); }
|
|
|
inline int promoted_sizeHintForRow(int row) const { return QTableView::sizeHintForRow(row); }
|
|
|
inline void promoted_timerEvent(QTimerEvent* event) { QTableView::timerEvent(event); }
|
|
|
inline void promoted_updateGeometries() { QTableView::updateGeometries(); }
|
|
|
inline int promoted_verticalOffset() const { return QTableView::verticalOffset(); }
|
|
|
inline void promoted_verticalScrollbarAction(int action) { QTableView::verticalScrollbarAction(action); }
|
|
|
inline QStyleOptionViewItem promoted_viewOptions() const { return QTableView::viewOptions(); }
|
|
|
inline QRect promoted_visualRect(const QModelIndex& index) const { return QTableView::visualRect(index); }
|
|
|
inline QRegion promoted_visualRegionForSelection(const QItemSelection& selection) const { return QTableView::visualRegionForSelection(selection); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTableView : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTableView* new_QTableView(QWidget* parent = 0);
|
|
|
void delete_QTableView(QTableView* obj) { delete obj; }
|
|
|
void clearSpans(QTableView* theWrappedObject);
|
|
|
int columnAt(QTableView* theWrappedObject, int x) const;
|
|
|
int columnSpan(QTableView* theWrappedObject, int row, int column) const;
|
|
|
int columnViewportPosition(QTableView* theWrappedObject, int column) const;
|
|
|
int columnWidth(QTableView* theWrappedObject, int column) const;
|
|
|
void currentChanged(QTableView* theWrappedObject, const QModelIndex& current, const QModelIndex& previous);
|
|
|
void doItemsLayout(QTableView* theWrappedObject);
|
|
|
Qt::PenStyle gridStyle(QTableView* theWrappedObject) const;
|
|
|
QHeaderView* horizontalHeader(QTableView* theWrappedObject) const;
|
|
|
int horizontalOffset(QTableView* theWrappedObject) const;
|
|
|
void horizontalScrollbarAction(QTableView* theWrappedObject, int action);
|
|
|
QModelIndex indexAt(QTableView* theWrappedObject, const QPoint& p) const;
|
|
|
bool isColumnHidden(QTableView* theWrappedObject, int column) const;
|
|
|
bool isCornerButtonEnabled(QTableView* theWrappedObject) const;
|
|
|
bool isIndexHidden(QTableView* theWrappedObject, const QModelIndex& index) const;
|
|
|
bool isRowHidden(QTableView* theWrappedObject, int row) const;
|
|
|
bool isSortingEnabled(QTableView* theWrappedObject) const;
|
|
|
void paintEvent(QTableView* theWrappedObject, QPaintEvent* e);
|
|
|
int rowAt(QTableView* theWrappedObject, int y) const;
|
|
|
int rowHeight(QTableView* theWrappedObject, int row) const;
|
|
|
int rowSpan(QTableView* theWrappedObject, int row, int column) const;
|
|
|
int rowViewportPosition(QTableView* theWrappedObject, int row) const;
|
|
|
void scrollContentsBy(QTableView* theWrappedObject, int dx, int dy);
|
|
|
void scrollTo(QTableView* theWrappedObject, const QModelIndex& index, QAbstractItemView::ScrollHint hint = QAbstractItemView::EnsureVisible);
|
|
|
QList<QModelIndex > selectedIndexes(QTableView* theWrappedObject) const;
|
|
|
void selectionChanged(QTableView* theWrappedObject, const QItemSelection& selected, const QItemSelection& deselected);
|
|
|
void setColumnHidden(QTableView* theWrappedObject, int column, bool hide);
|
|
|
void setColumnWidth(QTableView* theWrappedObject, int column, int width);
|
|
|
void setCornerButtonEnabled(QTableView* theWrappedObject, bool enable);
|
|
|
void setGridStyle(QTableView* theWrappedObject, Qt::PenStyle style);
|
|
|
void setHorizontalHeader(QTableView* theWrappedObject, QHeaderView* header);
|
|
|
void setModel(QTableView* theWrappedObject, QAbstractItemModel* model);
|
|
|
void setRootIndex(QTableView* theWrappedObject, const QModelIndex& index);
|
|
|
void setRowHeight(QTableView* theWrappedObject, int row, int height);
|
|
|
void setRowHidden(QTableView* theWrappedObject, int row, bool hide);
|
|
|
void setSelection(QTableView* theWrappedObject, const QRect& rect, QItemSelectionModel::SelectionFlags command);
|
|
|
void setSelectionModel(QTableView* theWrappedObject, QItemSelectionModel* selectionModel);
|
|
|
void setSortingEnabled(QTableView* theWrappedObject, bool enable);
|
|
|
void setSpan(QTableView* theWrappedObject, int row, int column, int rowSpan, int columnSpan);
|
|
|
void setVerticalHeader(QTableView* theWrappedObject, QHeaderView* header);
|
|
|
void setWordWrap(QTableView* theWrappedObject, bool on);
|
|
|
bool showGrid(QTableView* theWrappedObject) const;
|
|
|
int sizeHintForColumn(QTableView* theWrappedObject, int column) const;
|
|
|
int sizeHintForRow(QTableView* theWrappedObject, int row) const;
|
|
|
void sortByColumn(QTableView* theWrappedObject, int column, Qt::SortOrder order);
|
|
|
void timerEvent(QTableView* theWrappedObject, QTimerEvent* event);
|
|
|
void updateGeometries(QTableView* theWrappedObject);
|
|
|
QHeaderView* verticalHeader(QTableView* theWrappedObject) const;
|
|
|
int verticalOffset(QTableView* theWrappedObject) const;
|
|
|
void verticalScrollbarAction(QTableView* theWrappedObject, int action);
|
|
|
QStyleOptionViewItem viewOptions(QTableView* theWrappedObject) const;
|
|
|
QRect visualRect(QTableView* theWrappedObject, const QModelIndex& index) const;
|
|
|
QRegion visualRegionForSelection(QTableView* theWrappedObject, const QItemSelection& selection) const;
|
|
|
bool wordWrap(QTableView* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTableWidget : public QTableWidget
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTableWidget(QWidget* parent = 0):QTableWidget(parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTableWidget(int rows, int columns, QWidget* parent = 0):QTableWidget(rows, columns, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTableWidget();
|
|
|
|
|
|
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& previous);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual void dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight);
|
|
|
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 dropMimeData(int row, int column, const QMimeData* data, Qt::DropAction action);
|
|
|
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 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 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 languageChange();
|
|
|
virtual void leaveEvent(QEvent* arg__1);
|
|
|
virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
|
|
|
virtual QMimeData* mimeData(const QList<QTableWidgetItem* > items) const;
|
|
|
virtual QStringList mimeTypes() 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 QPaintEngine* paintEngine() const;
|
|
|
virtual void paintEvent(QPaintEvent* e);
|
|
|
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 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 setRootIndex(const QModelIndex& index);
|
|
|
virtual void setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags command);
|
|
|
virtual void setSelectionModel(QItemSelectionModel* selectionModel);
|
|
|
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 Qt::DropActions supportedDropActions() const;
|
|
|
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* event);
|
|
|
virtual QRect visualRect(const QModelIndex& index) const;
|
|
|
virtual QRegion visualRegionForSelection(const QItemSelection& selection) const;
|
|
|
virtual void wheelEvent(QWheelEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTableWidget : public QTableWidget
|
|
|
{ public:
|
|
|
inline void promoted_dropEvent(QDropEvent* event) { QTableWidget::dropEvent(event); }
|
|
|
inline bool promoted_dropMimeData(int row, int column, const QMimeData* data, Qt::DropAction action) { return QTableWidget::dropMimeData(row, column, data, action); }
|
|
|
inline bool promoted_event(QEvent* e) { return QTableWidget::event(e); }
|
|
|
inline QStringList promoted_mimeTypes() const { return QTableWidget::mimeTypes(); }
|
|
|
inline Qt::DropActions promoted_supportedDropActions() const { return QTableWidget::supportedDropActions(); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTableWidget : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTableWidget* new_QTableWidget(QWidget* parent = 0);
|
|
|
QTableWidget* new_QTableWidget(int rows, int columns, QWidget* parent = 0);
|
|
|
void delete_QTableWidget(QTableWidget* obj) { delete obj; }
|
|
|
QWidget* cellWidget(QTableWidget* theWrappedObject, int row, int column) const;
|
|
|
void closePersistentEditor(QTableWidget* theWrappedObject, QTableWidgetItem* item);
|
|
|
int column(QTableWidget* theWrappedObject, const QTableWidgetItem* item) const;
|
|
|
int columnCount(QTableWidget* theWrappedObject) const;
|
|
|
int currentColumn(QTableWidget* theWrappedObject) const;
|
|
|
QTableWidgetItem* currentItem(QTableWidget* theWrappedObject) const;
|
|
|
int currentRow(QTableWidget* theWrappedObject) const;
|
|
|
void dropEvent(QTableWidget* theWrappedObject, QDropEvent* event);
|
|
|
bool dropMimeData(QTableWidget* theWrappedObject, int row, int column, const QMimeData* data, Qt::DropAction action);
|
|
|
void editItem(QTableWidget* theWrappedObject, QTableWidgetItem* item);
|
|
|
bool event(QTableWidget* theWrappedObject, QEvent* e);
|
|
|
QList<QTableWidgetItem* > findItems(QTableWidget* theWrappedObject, const QString& text, Qt::MatchFlags flags) const;
|
|
|
QTableWidgetItem* horizontalHeaderItem(QTableWidget* theWrappedObject, int column) const;
|
|
|
QTableWidgetItem* item(QTableWidget* theWrappedObject, int row, int column) const;
|
|
|
QTableWidgetItem* itemAt(QTableWidget* theWrappedObject, const QPoint& p) const;
|
|
|
QTableWidgetItem* itemAt(QTableWidget* theWrappedObject, int x, int y) const;
|
|
|
const QTableWidgetItem* itemPrototype(QTableWidget* theWrappedObject) const;
|
|
|
QStringList mimeTypes(QTableWidget* theWrappedObject) const;
|
|
|
void openPersistentEditor(QTableWidget* theWrappedObject, QTableWidgetItem* item);
|
|
|
void removeCellWidget(QTableWidget* theWrappedObject, int row, int column);
|
|
|
int row(QTableWidget* theWrappedObject, const QTableWidgetItem* item) const;
|
|
|
int rowCount(QTableWidget* theWrappedObject) const;
|
|
|
QList<QTableWidgetItem* > selectedItems(QTableWidget* theWrappedObject);
|
|
|
QList<QTableWidgetSelectionRange > selectedRanges(QTableWidget* theWrappedObject) const;
|
|
|
void setCellWidget(QTableWidget* theWrappedObject, int row, int column, QWidget* widget);
|
|
|
void setColumnCount(QTableWidget* theWrappedObject, int columns);
|
|
|
void setCurrentCell(QTableWidget* theWrappedObject, int row, int column);
|
|
|
void setCurrentCell(QTableWidget* theWrappedObject, int row, int column, QItemSelectionModel::SelectionFlags command);
|
|
|
void setCurrentItem(QTableWidget* theWrappedObject, QTableWidgetItem* item);
|
|
|
void setCurrentItem(QTableWidget* theWrappedObject, QTableWidgetItem* item, QItemSelectionModel::SelectionFlags command);
|
|
|
void setHorizontalHeaderItem(QTableWidget* theWrappedObject, int column, QTableWidgetItem* item);
|
|
|
void setHorizontalHeaderLabels(QTableWidget* theWrappedObject, const QStringList& labels);
|
|
|
void setItem(QTableWidget* theWrappedObject, int row, int column, QTableWidgetItem* item);
|
|
|
void setItemPrototype(QTableWidget* theWrappedObject, const QTableWidgetItem* item);
|
|
|
void setRangeSelected(QTableWidget* theWrappedObject, const QTableWidgetSelectionRange& range, bool select);
|
|
|
void setRowCount(QTableWidget* theWrappedObject, int rows);
|
|
|
void setVerticalHeaderItem(QTableWidget* theWrappedObject, int row, QTableWidgetItem* item);
|
|
|
void setVerticalHeaderLabels(QTableWidget* theWrappedObject, const QStringList& labels);
|
|
|
void sortItems(QTableWidget* theWrappedObject, int column, Qt::SortOrder order = Qt::AscendingOrder);
|
|
|
Qt::DropActions supportedDropActions(QTableWidget* theWrappedObject) const;
|
|
|
QTableWidgetItem* takeHorizontalHeaderItem(QTableWidget* theWrappedObject, int column);
|
|
|
QTableWidgetItem* takeItem(QTableWidget* theWrappedObject, int row, int column);
|
|
|
QTableWidgetItem* takeVerticalHeaderItem(QTableWidget* theWrappedObject, int row);
|
|
|
QTableWidgetItem* verticalHeaderItem(QTableWidget* theWrappedObject, int row) const;
|
|
|
int visualColumn(QTableWidget* theWrappedObject, int logicalColumn) const;
|
|
|
QRect visualItemRect(QTableWidget* theWrappedObject, const QTableWidgetItem* item) const;
|
|
|
int visualRow(QTableWidget* theWrappedObject, int logicalRow) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTableWidgetItem : public QTableWidgetItem
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTableWidgetItem(const QIcon& icon, const QString& text, int type = Type):QTableWidgetItem(icon, text, type),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTableWidgetItem(const QString& text, int type = Type):QTableWidgetItem(text, type),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTableWidgetItem(int type = Type):QTableWidgetItem(type),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTableWidgetItem();
|
|
|
|
|
|
virtual QTableWidgetItem* clone() const;
|
|
|
virtual QVariant data(int role) const;
|
|
|
virtual bool __lt__(const QTableWidgetItem& other) const;
|
|
|
virtual void read(QDataStream& in);
|
|
|
virtual void setData(int role, const QVariant& value);
|
|
|
virtual void write(QDataStream& out) const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTableWidgetItem : public QTableWidgetItem
|
|
|
{ public:
|
|
|
inline QTableWidgetItem* promoted_clone() const { return QTableWidgetItem::clone(); }
|
|
|
inline QVariant promoted_data(int role) const { return QTableWidgetItem::data(role); }
|
|
|
inline void promoted_setData(int role, const QVariant& value) { QTableWidgetItem::setData(role, value); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTableWidgetItem : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(ItemType )
|
|
|
enum ItemType{
|
|
|
Type = QTableWidgetItem::Type, UserType = QTableWidgetItem::UserType};
|
|
|
public slots:
|
|
|
QTableWidgetItem* new_QTableWidgetItem(const QIcon& icon, const QString& text, int type = Type);
|
|
|
QTableWidgetItem* new_QTableWidgetItem(const QString& text, int type = Type);
|
|
|
QTableWidgetItem* new_QTableWidgetItem(int type = Type);
|
|
|
void delete_QTableWidgetItem(QTableWidgetItem* obj) { delete obj; }
|
|
|
QBrush background(QTableWidgetItem* theWrappedObject) const;
|
|
|
Qt::CheckState checkState(QTableWidgetItem* theWrappedObject) const;
|
|
|
QTableWidgetItem* clone(QTableWidgetItem* theWrappedObject) const;
|
|
|
int column(QTableWidgetItem* theWrappedObject) const;
|
|
|
QVariant data(QTableWidgetItem* theWrappedObject, int role) const;
|
|
|
Qt::ItemFlags flags(QTableWidgetItem* theWrappedObject) const;
|
|
|
QFont font(QTableWidgetItem* theWrappedObject) const;
|
|
|
QBrush foreground(QTableWidgetItem* theWrappedObject) const;
|
|
|
QIcon icon(QTableWidgetItem* theWrappedObject) const;
|
|
|
bool isSelected(QTableWidgetItem* theWrappedObject) const;
|
|
|
void writeTo(QTableWidgetItem* theWrappedObject, QDataStream& out);
|
|
|
void readFrom(QTableWidgetItem* theWrappedObject, QDataStream& in);
|
|
|
int row(QTableWidgetItem* theWrappedObject) const;
|
|
|
void setBackground(QTableWidgetItem* theWrappedObject, const QBrush& brush);
|
|
|
void setCheckState(QTableWidgetItem* theWrappedObject, Qt::CheckState state);
|
|
|
void setData(QTableWidgetItem* theWrappedObject, int role, const QVariant& value);
|
|
|
void setFlags(QTableWidgetItem* theWrappedObject, Qt::ItemFlags flags);
|
|
|
void setFont(QTableWidgetItem* theWrappedObject, const QFont& font);
|
|
|
void setForeground(QTableWidgetItem* theWrappedObject, const QBrush& brush);
|
|
|
void setIcon(QTableWidgetItem* theWrappedObject, const QIcon& icon);
|
|
|
void setSelected(QTableWidgetItem* theWrappedObject, bool select);
|
|
|
void setSizeHint(QTableWidgetItem* theWrappedObject, const QSize& size);
|
|
|
void setStatusTip(QTableWidgetItem* theWrappedObject, const QString& statusTip);
|
|
|
void setText(QTableWidgetItem* theWrappedObject, const QString& text);
|
|
|
void setTextAlignment(QTableWidgetItem* theWrappedObject, int alignment);
|
|
|
void setToolTip(QTableWidgetItem* theWrappedObject, const QString& toolTip);
|
|
|
void setWhatsThis(QTableWidgetItem* theWrappedObject, const QString& whatsThis);
|
|
|
QSize sizeHint(QTableWidgetItem* theWrappedObject) const;
|
|
|
QString statusTip(QTableWidgetItem* theWrappedObject) const;
|
|
|
QTableWidget* tableWidget(QTableWidgetItem* theWrappedObject) const;
|
|
|
QString text(QTableWidgetItem* theWrappedObject) const;
|
|
|
int textAlignment(QTableWidgetItem* theWrappedObject) const;
|
|
|
QString toolTip(QTableWidgetItem* theWrappedObject) const;
|
|
|
int type(QTableWidgetItem* theWrappedObject) const;
|
|
|
QString whatsThis(QTableWidgetItem* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QTableWidgetSelectionRange : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTableWidgetSelectionRange* new_QTableWidgetSelectionRange();
|
|
|
QTableWidgetSelectionRange* new_QTableWidgetSelectionRange(const QTableWidgetSelectionRange& other);
|
|
|
QTableWidgetSelectionRange* new_QTableWidgetSelectionRange(int top, int left, int bottom, int right);
|
|
|
void delete_QTableWidgetSelectionRange(QTableWidgetSelectionRange* obj) { delete obj; }
|
|
|
int bottomRow(QTableWidgetSelectionRange* theWrappedObject) const;
|
|
|
int columnCount(QTableWidgetSelectionRange* theWrappedObject) const;
|
|
|
int leftColumn(QTableWidgetSelectionRange* theWrappedObject) const;
|
|
|
int rightColumn(QTableWidgetSelectionRange* theWrappedObject) const;
|
|
|
int rowCount(QTableWidgetSelectionRange* theWrappedObject) const;
|
|
|
int topRow(QTableWidgetSelectionRange* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTabletEvent : public QTabletEvent
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTabletEvent(QEvent::Type t, const QPoint& pos, const QPoint& globalPos, const QPointF& hiResGlobalPos, int device, int pointerType, qreal pressure, int xTilt, int yTilt, qreal tangentialPressure, qreal rotation, int z, Qt::KeyboardModifiers keyState, qint64 uniqueID):QTabletEvent(t, pos, globalPos, hiResGlobalPos, device, pointerType, pressure, xTilt, yTilt, tangentialPressure, rotation, z, keyState, uniqueID),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTabletEvent();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTabletEvent : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(TabletDevice PointerType )
|
|
|
enum TabletDevice{
|
|
|
NoDevice = QTabletEvent::NoDevice, Puck = QTabletEvent::Puck, Stylus = QTabletEvent::Stylus, Airbrush = QTabletEvent::Airbrush, FourDMouse = QTabletEvent::FourDMouse, XFreeEraser = QTabletEvent::XFreeEraser, RotationStylus = QTabletEvent::RotationStylus};
|
|
|
enum PointerType{
|
|
|
UnknownPointer = QTabletEvent::UnknownPointer, Pen = QTabletEvent::Pen, Cursor = QTabletEvent::Cursor, Eraser = QTabletEvent::Eraser};
|
|
|
public slots:
|
|
|
QTabletEvent* new_QTabletEvent(QEvent::Type t, const QPoint& pos, const QPoint& globalPos, const QPointF& hiResGlobalPos, int device, int pointerType, qreal pressure, int xTilt, int yTilt, qreal tangentialPressure, qreal rotation, int z, Qt::KeyboardModifiers keyState, qint64 uniqueID);
|
|
|
void delete_QTabletEvent(QTabletEvent* obj) { delete obj; }
|
|
|
QTabletEvent::TabletDevice device(QTabletEvent* theWrappedObject) const;
|
|
|
const QPoint* globalPos(QTabletEvent* theWrappedObject) const;
|
|
|
int globalX(QTabletEvent* theWrappedObject) const;
|
|
|
int globalY(QTabletEvent* theWrappedObject) const;
|
|
|
const QPointF* hiResGlobalPos(QTabletEvent* theWrappedObject) const;
|
|
|
qreal hiResGlobalX(QTabletEvent* theWrappedObject) const;
|
|
|
qreal hiResGlobalY(QTabletEvent* theWrappedObject) const;
|
|
|
QTabletEvent::PointerType pointerType(QTabletEvent* theWrappedObject) const;
|
|
|
const QPoint* pos(QTabletEvent* theWrappedObject) const;
|
|
|
qreal pressure(QTabletEvent* theWrappedObject) const;
|
|
|
qreal rotation(QTabletEvent* theWrappedObject) const;
|
|
|
qreal tangentialPressure(QTabletEvent* theWrappedObject) const;
|
|
|
qint64 uniqueId(QTabletEvent* theWrappedObject) const;
|
|
|
int x(QTabletEvent* theWrappedObject) const;
|
|
|
int xTilt(QTabletEvent* theWrappedObject) const;
|
|
|
int y(QTabletEvent* theWrappedObject) const;
|
|
|
int yTilt(QTabletEvent* theWrappedObject) const;
|
|
|
int z(QTabletEvent* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTapAndHoldGesture : public QTapAndHoldGesture
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTapAndHoldGesture(QObject* parent = 0):QTapAndHoldGesture(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTapAndHoldGesture();
|
|
|
|
|
|
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_QTapAndHoldGesture : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTapAndHoldGesture* new_QTapAndHoldGesture(QObject* parent = 0);
|
|
|
void delete_QTapAndHoldGesture(QTapAndHoldGesture* obj) { delete obj; }
|
|
|
QPointF position(QTapAndHoldGesture* theWrappedObject) const;
|
|
|
void setPosition(QTapAndHoldGesture* theWrappedObject, const QPointF& pos);
|
|
|
void static_QTapAndHoldGesture_setTimeout(int msecs);
|
|
|
int static_QTapAndHoldGesture_timeout();
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTapGesture : public QTapGesture
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTapGesture(QObject* parent = 0):QTapGesture(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTapGesture();
|
|
|
|
|
|
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_QTapGesture : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTapGesture* new_QTapGesture(QObject* parent = 0);
|
|
|
void delete_QTapGesture(QTapGesture* obj) { delete obj; }
|
|
|
QPointF position(QTapGesture* theWrappedObject) const;
|
|
|
void setPosition(QTapGesture* theWrappedObject, const QPointF& pos);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QTextBlock : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTextBlock* new_QTextBlock();
|
|
|
QTextBlock* new_QTextBlock(const QTextBlock& o);
|
|
|
void delete_QTextBlock(QTextBlock* obj) { delete obj; }
|
|
|
QTextBlock::iterator begin(QTextBlock* theWrappedObject) const;
|
|
|
QTextBlockFormat blockFormat(QTextBlock* theWrappedObject) const;
|
|
|
int blockFormatIndex(QTextBlock* theWrappedObject) const;
|
|
|
int blockNumber(QTextBlock* theWrappedObject) const;
|
|
|
QTextCharFormat charFormat(QTextBlock* theWrappedObject) const;
|
|
|
int charFormatIndex(QTextBlock* theWrappedObject) const;
|
|
|
void clearLayout(QTextBlock* theWrappedObject);
|
|
|
bool contains(QTextBlock* theWrappedObject, int position) const;
|
|
|
const QTextDocument* document(QTextBlock* theWrappedObject) const;
|
|
|
QTextBlock::iterator end(QTextBlock* theWrappedObject) const;
|
|
|
int firstLineNumber(QTextBlock* theWrappedObject) const;
|
|
|
int fragmentIndex(QTextBlock* theWrappedObject) const;
|
|
|
bool isValid(QTextBlock* theWrappedObject) const;
|
|
|
bool isVisible(QTextBlock* theWrappedObject) const;
|
|
|
QTextLayout* layout(QTextBlock* theWrappedObject) const;
|
|
|
int length(QTextBlock* theWrappedObject) const;
|
|
|
int lineCount(QTextBlock* theWrappedObject) const;
|
|
|
QTextBlock next(QTextBlock* theWrappedObject) const;
|
|
|
bool __ne__(QTextBlock* theWrappedObject, const QTextBlock& o) const;
|
|
|
bool __lt__(QTextBlock* theWrappedObject, const QTextBlock& o) const;
|
|
|
bool __eq__(QTextBlock* theWrappedObject, const QTextBlock& o) const;
|
|
|
int position(QTextBlock* theWrappedObject) const;
|
|
|
QTextBlock previous(QTextBlock* theWrappedObject) const;
|
|
|
int revision(QTextBlock* theWrappedObject) const;
|
|
|
void setLineCount(QTextBlock* theWrappedObject, int count);
|
|
|
void setRevision(QTextBlock* theWrappedObject, int rev);
|
|
|
void setUserData(QTextBlock* theWrappedObject, QTextBlockUserData* data);
|
|
|
void setUserState(QTextBlock* theWrappedObject, int state);
|
|
|
void setVisible(QTextBlock* theWrappedObject, bool visible);
|
|
|
QString text(QTextBlock* theWrappedObject) const;
|
|
|
Qt::LayoutDirection textDirection(QTextBlock* theWrappedObject) const;
|
|
|
QTextList* textList(QTextBlock* theWrappedObject) const;
|
|
|
QTextBlockUserData* userData(QTextBlock* theWrappedObject) const;
|
|
|
int userState(QTextBlock* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextBlockFormat : public QTextBlockFormat
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextBlockFormat():QTextBlockFormat(),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTextBlockFormat(const QTextFormat& fmt):QTextBlockFormat(fmt),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextBlockFormat();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTextBlockFormat : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(LineHeightTypes )
|
|
|
enum LineHeightTypes{
|
|
|
SingleHeight = QTextBlockFormat::SingleHeight, ProportionalHeight = QTextBlockFormat::ProportionalHeight, FixedHeight = QTextBlockFormat::FixedHeight, MinimumHeight = QTextBlockFormat::MinimumHeight, LineDistanceHeight = QTextBlockFormat::LineDistanceHeight};
|
|
|
public slots:
|
|
|
QTextBlockFormat* new_QTextBlockFormat();
|
|
|
QTextBlockFormat* new_QTextBlockFormat(const QTextBlockFormat& other) {
|
|
|
PythonQtShell_QTextBlockFormat* a = new PythonQtShell_QTextBlockFormat();
|
|
|
*((QTextBlockFormat*)a) = other;
|
|
|
return a; }
|
|
|
void delete_QTextBlockFormat(QTextBlockFormat* obj) { delete obj; }
|
|
|
Qt::Alignment alignment(QTextBlockFormat* theWrappedObject) const;
|
|
|
qreal bottomMargin(QTextBlockFormat* theWrappedObject) const;
|
|
|
int indent(QTextBlockFormat* theWrappedObject) const;
|
|
|
bool isValid(QTextBlockFormat* theWrappedObject) const;
|
|
|
qreal leftMargin(QTextBlockFormat* theWrappedObject) const;
|
|
|
qreal lineHeight(QTextBlockFormat* theWrappedObject) const;
|
|
|
qreal lineHeight(QTextBlockFormat* theWrappedObject, qreal scriptLineHeight, qreal scaling) const;
|
|
|
int lineHeightType(QTextBlockFormat* theWrappedObject) const;
|
|
|
bool nonBreakableLines(QTextBlockFormat* theWrappedObject) const;
|
|
|
QTextFormat::PageBreakFlags pageBreakPolicy(QTextBlockFormat* theWrappedObject) const;
|
|
|
qreal rightMargin(QTextBlockFormat* theWrappedObject) const;
|
|
|
void setAlignment(QTextBlockFormat* theWrappedObject, Qt::Alignment alignment);
|
|
|
void setBottomMargin(QTextBlockFormat* theWrappedObject, qreal margin);
|
|
|
void setIndent(QTextBlockFormat* theWrappedObject, int indent);
|
|
|
void setLeftMargin(QTextBlockFormat* theWrappedObject, qreal margin);
|
|
|
void setLineHeight(QTextBlockFormat* theWrappedObject, qreal height, int heightType);
|
|
|
void setNonBreakableLines(QTextBlockFormat* theWrappedObject, bool b);
|
|
|
void setPageBreakPolicy(QTextBlockFormat* theWrappedObject, QTextFormat::PageBreakFlags flags);
|
|
|
void setRightMargin(QTextBlockFormat* theWrappedObject, qreal margin);
|
|
|
void setTabPositions(QTextBlockFormat* theWrappedObject, const QList<QTextOption::Tab >& tabs);
|
|
|
void setTextIndent(QTextBlockFormat* theWrappedObject, qreal aindent);
|
|
|
void setTopMargin(QTextBlockFormat* theWrappedObject, qreal margin);
|
|
|
QList<QTextOption::Tab > tabPositions(QTextBlockFormat* theWrappedObject) const;
|
|
|
qreal textIndent(QTextBlockFormat* theWrappedObject) const;
|
|
|
qreal topMargin(QTextBlockFormat* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextBlockGroup : public QTextBlockGroup
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextBlockGroup(QTextDocument* doc):QTextBlockGroup(doc),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextBlockGroup();
|
|
|
|
|
|
virtual void blockFormatChanged(const QTextBlock& block);
|
|
|
virtual void blockInserted(const QTextBlock& block);
|
|
|
virtual void blockRemoved(const QTextBlock& block);
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTextBlockGroup : public QTextBlockGroup
|
|
|
{ public:
|
|
|
inline void promoted_blockFormatChanged(const QTextBlock& block) { QTextBlockGroup::blockFormatChanged(block); }
|
|
|
inline void promoted_blockInserted(const QTextBlock& block) { QTextBlockGroup::blockInserted(block); }
|
|
|
inline void promoted_blockRemoved(const QTextBlock& block) { QTextBlockGroup::blockRemoved(block); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTextBlockGroup : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
void blockFormatChanged(QTextBlockGroup* theWrappedObject, const QTextBlock& block);
|
|
|
void blockInserted(QTextBlockGroup* theWrappedObject, const QTextBlock& block);
|
|
|
void blockRemoved(QTextBlockGroup* theWrappedObject, const QTextBlock& block);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextBlockUserData : public QTextBlockUserData
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextBlockUserData():QTextBlockUserData(),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextBlockUserData();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTextBlockUserData : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTextBlockUserData* new_QTextBlockUserData();
|
|
|
void delete_QTextBlockUserData(QTextBlockUserData* obj) { delete obj; }
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextBrowser : public QTextBrowser
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextBrowser(QWidget* parent = 0):QTextBrowser(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextBrowser();
|
|
|
|
|
|
virtual void actionEvent(QActionEvent* arg__1);
|
|
|
virtual void backward();
|
|
|
virtual bool canInsertFromMimeData(const QMimeData* source) const;
|
|
|
virtual void changeEvent(QEvent* e);
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void closeEvent(QCloseEvent* arg__1);
|
|
|
virtual void contextMenuEvent(QContextMenuEvent* e);
|
|
|
virtual QMimeData* createMimeDataFromSelection() const;
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual int devType() const;
|
|
|
virtual void dragEnterEvent(QDragEnterEvent* e);
|
|
|
virtual void dragLeaveEvent(QDragLeaveEvent* e);
|
|
|
virtual void dragMoveEvent(QDragMoveEvent* e);
|
|
|
virtual void dropEvent(QDropEvent* e);
|
|
|
virtual void enterEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* e);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void focusInEvent(QFocusEvent* e);
|
|
|
virtual bool focusNextPrevChild(bool next);
|
|
|
virtual void focusOutEvent(QFocusEvent* ev);
|
|
|
virtual void forward();
|
|
|
virtual int heightForWidth(int arg__1) const;
|
|
|
virtual void hideEvent(QHideEvent* arg__1);
|
|
|
virtual void home();
|
|
|
virtual void inputMethodEvent(QInputMethodEvent* arg__1);
|
|
|
virtual QVariant inputMethodQuery(Qt::InputMethodQuery property) const;
|
|
|
virtual void insertFromMimeData(const QMimeData* source);
|
|
|
virtual void keyPressEvent(QKeyEvent* ev);
|
|
|
virtual void keyReleaseEvent(QKeyEvent* e);
|
|
|
virtual void languageChange();
|
|
|
virtual void leaveEvent(QEvent* arg__1);
|
|
|
virtual QVariant loadResource(int type, const QUrl& name);
|
|
|
virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
|
|
|
virtual void mouseDoubleClickEvent(QMouseEvent* e);
|
|
|
virtual void mouseMoveEvent(QMouseEvent* ev);
|
|
|
virtual void mousePressEvent(QMouseEvent* ev);
|
|
|
virtual void mouseReleaseEvent(QMouseEvent* ev);
|
|
|
virtual void moveEvent(QMoveEvent* arg__1);
|
|
|
virtual QPaintEngine* paintEngine() const;
|
|
|
virtual void paintEvent(QPaintEvent* e);
|
|
|
virtual void reload();
|
|
|
virtual void resizeEvent(QResizeEvent* e);
|
|
|
virtual void scrollContentsBy(int dx, int dy);
|
|
|
virtual void setSource(const QUrl& name);
|
|
|
virtual void showEvent(QShowEvent* arg__1);
|
|
|
virtual void tabletEvent(QTabletEvent* arg__1);
|
|
|
virtual void timerEvent(QTimerEvent* e);
|
|
|
virtual bool viewportEvent(QEvent* arg__1);
|
|
|
virtual void wheelEvent(QWheelEvent* e);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTextBrowser : public QTextBrowser
|
|
|
{ public:
|
|
|
inline void promoted_backward() { QTextBrowser::backward(); }
|
|
|
inline bool promoted_event(QEvent* e) { return QTextBrowser::event(e); }
|
|
|
inline bool promoted_focusNextPrevChild(bool next) { return QTextBrowser::focusNextPrevChild(next); }
|
|
|
inline void promoted_focusOutEvent(QFocusEvent* ev) { QTextBrowser::focusOutEvent(ev); }
|
|
|
inline void promoted_forward() { QTextBrowser::forward(); }
|
|
|
inline void promoted_home() { QTextBrowser::home(); }
|
|
|
inline void promoted_keyPressEvent(QKeyEvent* ev) { QTextBrowser::keyPressEvent(ev); }
|
|
|
inline QVariant promoted_loadResource(int type, const QUrl& name) { return QTextBrowser::loadResource(type, name); }
|
|
|
inline void promoted_mouseMoveEvent(QMouseEvent* ev) { QTextBrowser::mouseMoveEvent(ev); }
|
|
|
inline void promoted_mousePressEvent(QMouseEvent* ev) { QTextBrowser::mousePressEvent(ev); }
|
|
|
inline void promoted_mouseReleaseEvent(QMouseEvent* ev) { QTextBrowser::mouseReleaseEvent(ev); }
|
|
|
inline void promoted_paintEvent(QPaintEvent* e) { QTextBrowser::paintEvent(e); }
|
|
|
inline void promoted_reload() { QTextBrowser::reload(); }
|
|
|
inline void promoted_setSource(const QUrl& name) { QTextBrowser::setSource(name); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTextBrowser : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTextBrowser* new_QTextBrowser(QWidget* parent = 0);
|
|
|
void delete_QTextBrowser(QTextBrowser* obj) { delete obj; }
|
|
|
void backward(QTextBrowser* theWrappedObject);
|
|
|
int backwardHistoryCount(QTextBrowser* theWrappedObject) const;
|
|
|
void clearHistory(QTextBrowser* theWrappedObject);
|
|
|
bool event(QTextBrowser* theWrappedObject, QEvent* e);
|
|
|
bool focusNextPrevChild(QTextBrowser* theWrappedObject, bool next);
|
|
|
void focusOutEvent(QTextBrowser* theWrappedObject, QFocusEvent* ev);
|
|
|
void forward(QTextBrowser* theWrappedObject);
|
|
|
int forwardHistoryCount(QTextBrowser* theWrappedObject) const;
|
|
|
QString historyTitle(QTextBrowser* theWrappedObject, int arg__1) const;
|
|
|
QUrl historyUrl(QTextBrowser* theWrappedObject, int arg__1) const;
|
|
|
void home(QTextBrowser* theWrappedObject);
|
|
|
bool isBackwardAvailable(QTextBrowser* theWrappedObject) const;
|
|
|
bool isForwardAvailable(QTextBrowser* theWrappedObject) const;
|
|
|
void keyPressEvent(QTextBrowser* theWrappedObject, QKeyEvent* ev);
|
|
|
QVariant loadResource(QTextBrowser* theWrappedObject, int type, const QUrl& name);
|
|
|
void mouseMoveEvent(QTextBrowser* theWrappedObject, QMouseEvent* ev);
|
|
|
void mousePressEvent(QTextBrowser* theWrappedObject, QMouseEvent* ev);
|
|
|
void mouseReleaseEvent(QTextBrowser* theWrappedObject, QMouseEvent* ev);
|
|
|
bool openExternalLinks(QTextBrowser* theWrappedObject) const;
|
|
|
bool openLinks(QTextBrowser* theWrappedObject) const;
|
|
|
void paintEvent(QTextBrowser* theWrappedObject, QPaintEvent* e);
|
|
|
void reload(QTextBrowser* theWrappedObject);
|
|
|
QStringList searchPaths(QTextBrowser* theWrappedObject) const;
|
|
|
void setOpenExternalLinks(QTextBrowser* theWrappedObject, bool open);
|
|
|
void setOpenLinks(QTextBrowser* theWrappedObject, bool open);
|
|
|
void setSearchPaths(QTextBrowser* theWrappedObject, const QStringList& paths);
|
|
|
void setSource(QTextBrowser* theWrappedObject, const QUrl& name);
|
|
|
QUrl source(QTextBrowser* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextCharFormat : public QTextCharFormat
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextCharFormat():QTextCharFormat(),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTextCharFormat(const QTextFormat& fmt):QTextCharFormat(fmt),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextCharFormat();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTextCharFormat : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(VerticalAlignment UnderlineStyle )
|
|
|
enum VerticalAlignment{
|
|
|
AlignNormal = QTextCharFormat::AlignNormal, AlignSuperScript = QTextCharFormat::AlignSuperScript, AlignSubScript = QTextCharFormat::AlignSubScript, AlignMiddle = QTextCharFormat::AlignMiddle, AlignTop = QTextCharFormat::AlignTop, AlignBottom = QTextCharFormat::AlignBottom, AlignBaseline = QTextCharFormat::AlignBaseline};
|
|
|
enum UnderlineStyle{
|
|
|
NoUnderline = QTextCharFormat::NoUnderline, SingleUnderline = QTextCharFormat::SingleUnderline, DashUnderline = QTextCharFormat::DashUnderline, DotLine = QTextCharFormat::DotLine, DashDotLine = QTextCharFormat::DashDotLine, DashDotDotLine = QTextCharFormat::DashDotDotLine, WaveUnderline = QTextCharFormat::WaveUnderline, SpellCheckUnderline = QTextCharFormat::SpellCheckUnderline};
|
|
|
public slots:
|
|
|
QTextCharFormat* new_QTextCharFormat();
|
|
|
QTextCharFormat* new_QTextCharFormat(const QTextCharFormat& other) {
|
|
|
PythonQtShell_QTextCharFormat* a = new PythonQtShell_QTextCharFormat();
|
|
|
*((QTextCharFormat*)a) = other;
|
|
|
return a; }
|
|
|
void delete_QTextCharFormat(QTextCharFormat* obj) { delete obj; }
|
|
|
QString anchorHref(QTextCharFormat* theWrappedObject) const;
|
|
|
QStringList anchorNames(QTextCharFormat* theWrappedObject) const;
|
|
|
QFont font(QTextCharFormat* theWrappedObject) const;
|
|
|
QFont::Capitalization fontCapitalization(QTextCharFormat* theWrappedObject) const;
|
|
|
QString fontFamily(QTextCharFormat* theWrappedObject) const;
|
|
|
bool fontFixedPitch(QTextCharFormat* theWrappedObject) const;
|
|
|
QFont::HintingPreference fontHintingPreference(QTextCharFormat* theWrappedObject) const;
|
|
|
bool fontItalic(QTextCharFormat* theWrappedObject) const;
|
|
|
bool fontKerning(QTextCharFormat* theWrappedObject) const;
|
|
|
qreal fontLetterSpacing(QTextCharFormat* theWrappedObject) const;
|
|
|
bool fontOverline(QTextCharFormat* theWrappedObject) const;
|
|
|
qreal fontPointSize(QTextCharFormat* theWrappedObject) const;
|
|
|
bool fontStrikeOut(QTextCharFormat* theWrappedObject) const;
|
|
|
QFont::StyleHint fontStyleHint(QTextCharFormat* theWrappedObject) const;
|
|
|
QFont::StyleStrategy fontStyleStrategy(QTextCharFormat* theWrappedObject) const;
|
|
|
bool fontUnderline(QTextCharFormat* theWrappedObject) const;
|
|
|
int fontWeight(QTextCharFormat* theWrappedObject) const;
|
|
|
qreal fontWordSpacing(QTextCharFormat* theWrappedObject) const;
|
|
|
bool isAnchor(QTextCharFormat* theWrappedObject) const;
|
|
|
bool isValid(QTextCharFormat* theWrappedObject) const;
|
|
|
void setAnchor(QTextCharFormat* theWrappedObject, bool anchor);
|
|
|
void setAnchorHref(QTextCharFormat* theWrappedObject, const QString& value);
|
|
|
void setAnchorNames(QTextCharFormat* theWrappedObject, const QStringList& names);
|
|
|
void setFont(QTextCharFormat* theWrappedObject, const QFont& font);
|
|
|
void setFontCapitalization(QTextCharFormat* theWrappedObject, QFont::Capitalization capitalization);
|
|
|
void setFontFamily(QTextCharFormat* theWrappedObject, const QString& family);
|
|
|
void setFontFixedPitch(QTextCharFormat* theWrappedObject, bool fixedPitch);
|
|
|
void setFontHintingPreference(QTextCharFormat* theWrappedObject, QFont::HintingPreference hintingPreference);
|
|
|
void setFontItalic(QTextCharFormat* theWrappedObject, bool italic);
|
|
|
void setFontKerning(QTextCharFormat* theWrappedObject, bool enable);
|
|
|
void setFontLetterSpacing(QTextCharFormat* theWrappedObject, qreal spacing);
|
|
|
void setFontOverline(QTextCharFormat* theWrappedObject, bool overline);
|
|
|
void setFontPointSize(QTextCharFormat* theWrappedObject, qreal size);
|
|
|
void setFontStrikeOut(QTextCharFormat* theWrappedObject, bool strikeOut);
|
|
|
void setFontStyleHint(QTextCharFormat* theWrappedObject, QFont::StyleHint hint, QFont::StyleStrategy strategy = QFont::PreferDefault);
|
|
|
void setFontStyleStrategy(QTextCharFormat* theWrappedObject, QFont::StyleStrategy strategy);
|
|
|
void setFontUnderline(QTextCharFormat* theWrappedObject, bool underline);
|
|
|
void setFontWeight(QTextCharFormat* theWrappedObject, int weight);
|
|
|
void setFontWordSpacing(QTextCharFormat* theWrappedObject, qreal spacing);
|
|
|
void setTableCellColumnSpan(QTextCharFormat* theWrappedObject, int tableCellColumnSpan);
|
|
|
void setTableCellRowSpan(QTextCharFormat* theWrappedObject, int tableCellRowSpan);
|
|
|
void setTextOutline(QTextCharFormat* theWrappedObject, const QPen& pen);
|
|
|
void setToolTip(QTextCharFormat* theWrappedObject, const QString& tip);
|
|
|
void setUnderlineColor(QTextCharFormat* theWrappedObject, const QColor& color);
|
|
|
void setUnderlineStyle(QTextCharFormat* theWrappedObject, QTextCharFormat::UnderlineStyle style);
|
|
|
void setVerticalAlignment(QTextCharFormat* theWrappedObject, QTextCharFormat::VerticalAlignment alignment);
|
|
|
int tableCellColumnSpan(QTextCharFormat* theWrappedObject) const;
|
|
|
int tableCellRowSpan(QTextCharFormat* theWrappedObject) const;
|
|
|
QPen textOutline(QTextCharFormat* theWrappedObject) const;
|
|
|
QString toolTip(QTextCharFormat* theWrappedObject) const;
|
|
|
QColor underlineColor(QTextCharFormat* theWrappedObject) const;
|
|
|
QTextCharFormat::UnderlineStyle underlineStyle(QTextCharFormat* theWrappedObject) const;
|
|
|
QTextCharFormat::VerticalAlignment verticalAlignment(QTextCharFormat* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextCodecPlugin : public QTextCodecPlugin
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextCodecPlugin(QObject* parent = 0):QTextCodecPlugin(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextCodecPlugin();
|
|
|
|
|
|
virtual QList<QByteArray > aliases() const;
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual QTextCodec* createForMib(int mib);
|
|
|
virtual QTextCodec* createForName(const QByteArray& name);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual QList<int > mibEnums() const;
|
|
|
virtual QList<QByteArray > names() const;
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTextCodecPlugin : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTextCodecPlugin* new_QTextCodecPlugin(QObject* parent = 0);
|
|
|
void delete_QTextCodecPlugin(QTextCodecPlugin* obj) { delete obj; }
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QTextCursor : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(MoveMode MoveOperation SelectionType )
|
|
|
enum MoveMode{
|
|
|
MoveAnchor = QTextCursor::MoveAnchor, KeepAnchor = QTextCursor::KeepAnchor};
|
|
|
enum MoveOperation{
|
|
|
NoMove = QTextCursor::NoMove, Start = QTextCursor::Start, Up = QTextCursor::Up, StartOfLine = QTextCursor::StartOfLine, StartOfBlock = QTextCursor::StartOfBlock, StartOfWord = QTextCursor::StartOfWord, PreviousBlock = QTextCursor::PreviousBlock, PreviousCharacter = QTextCursor::PreviousCharacter, PreviousWord = QTextCursor::PreviousWord, Left = QTextCursor::Left, WordLeft = QTextCursor::WordLeft, End = QTextCursor::End, Down = QTextCursor::Down, EndOfLine = QTextCursor::EndOfLine, EndOfWord = QTextCursor::EndOfWord, EndOfBlock = QTextCursor::EndOfBlock, NextBlock = QTextCursor::NextBlock, NextCharacter = QTextCursor::NextCharacter, NextWord = QTextCursor::NextWord, Right = QTextCursor::Right, WordRight = QTextCursor::WordRight, NextCell = QTextCursor::NextCell, PreviousCell = QTextCursor::PreviousCell, NextRow = QTextCursor::NextRow, PreviousRow = QTextCursor::PreviousRow};
|
|
|
enum SelectionType{
|
|
|
WordUnderCursor = QTextCursor::WordUnderCursor, LineUnderCursor = QTextCursor::LineUnderCursor, BlockUnderCursor = QTextCursor::BlockUnderCursor, Document = QTextCursor::Document};
|
|
|
public slots:
|
|
|
QTextCursor* new_QTextCursor();
|
|
|
QTextCursor* new_QTextCursor(QTextDocument* document);
|
|
|
QTextCursor* new_QTextCursor(QTextFrame* frame);
|
|
|
QTextCursor* new_QTextCursor(const QTextBlock& block);
|
|
|
QTextCursor* new_QTextCursor(const QTextCursor& cursor);
|
|
|
void delete_QTextCursor(QTextCursor* obj) { delete obj; }
|
|
|
int anchor(QTextCursor* theWrappedObject) const;
|
|
|
bool atBlockEnd(QTextCursor* theWrappedObject) const;
|
|
|
bool atBlockStart(QTextCursor* theWrappedObject) const;
|
|
|
bool atEnd(QTextCursor* theWrappedObject) const;
|
|
|
bool atStart(QTextCursor* theWrappedObject) const;
|
|
|
void beginEditBlock(QTextCursor* theWrappedObject);
|
|
|
QTextBlock block(QTextCursor* theWrappedObject) const;
|
|
|
QTextCharFormat blockCharFormat(QTextCursor* theWrappedObject) const;
|
|
|
QTextBlockFormat blockFormat(QTextCursor* theWrappedObject) const;
|
|
|
int blockNumber(QTextCursor* theWrappedObject) const;
|
|
|
QTextCharFormat charFormat(QTextCursor* theWrappedObject) const;
|
|
|
void clearSelection(QTextCursor* theWrappedObject);
|
|
|
int columnNumber(QTextCursor* theWrappedObject) const;
|
|
|
QTextList* createList(QTextCursor* theWrappedObject, QTextListFormat::Style style);
|
|
|
QTextList* createList(QTextCursor* theWrappedObject, const QTextListFormat& format);
|
|
|
QTextFrame* currentFrame(QTextCursor* theWrappedObject) const;
|
|
|
QTextList* currentList(QTextCursor* theWrappedObject) const;
|
|
|
QTextTable* currentTable(QTextCursor* theWrappedObject) const;
|
|
|
void deleteChar(QTextCursor* theWrappedObject);
|
|
|
void deletePreviousChar(QTextCursor* theWrappedObject);
|
|
|
QTextDocument* document(QTextCursor* theWrappedObject) const;
|
|
|
void endEditBlock(QTextCursor* theWrappedObject);
|
|
|
bool hasComplexSelection(QTextCursor* theWrappedObject) const;
|
|
|
bool hasSelection(QTextCursor* theWrappedObject) const;
|
|
|
void insertBlock(QTextCursor* theWrappedObject);
|
|
|
void insertBlock(QTextCursor* theWrappedObject, const QTextBlockFormat& format);
|
|
|
void insertBlock(QTextCursor* theWrappedObject, const QTextBlockFormat& format, const QTextCharFormat& charFormat);
|
|
|
void insertFragment(QTextCursor* theWrappedObject, const QTextDocumentFragment& fragment);
|
|
|
QTextFrame* insertFrame(QTextCursor* theWrappedObject, const QTextFrameFormat& format);
|
|
|
void insertHtml(QTextCursor* theWrappedObject, const QString& html);
|
|
|
void insertImage(QTextCursor* theWrappedObject, const QImage& image, const QString& name = QString());
|
|
|
void insertImage(QTextCursor* theWrappedObject, const QString& name);
|
|
|
void insertImage(QTextCursor* theWrappedObject, const QTextImageFormat& format);
|
|
|
void insertImage(QTextCursor* theWrappedObject, const QTextImageFormat& format, QTextFrameFormat::Position alignment);
|
|
|
QTextList* insertList(QTextCursor* theWrappedObject, QTextListFormat::Style style);
|
|
|
QTextList* insertList(QTextCursor* theWrappedObject, const QTextListFormat& format);
|
|
|
QTextTable* insertTable(QTextCursor* theWrappedObject, int rows, int cols);
|
|
|
QTextTable* insertTable(QTextCursor* theWrappedObject, int rows, int cols, const QTextTableFormat& format);
|
|
|
void insertText(QTextCursor* theWrappedObject, const QString& text);
|
|
|
void insertText(QTextCursor* theWrappedObject, const QString& text, const QTextCharFormat& format);
|
|
|
bool isCopyOf(QTextCursor* theWrappedObject, const QTextCursor& other) const;
|
|
|
bool isNull(QTextCursor* theWrappedObject) const;
|
|
|
void joinPreviousEditBlock(QTextCursor* theWrappedObject);
|
|
|
bool keepPositionOnInsert(QTextCursor* theWrappedObject) const;
|
|
|
void mergeBlockCharFormat(QTextCursor* theWrappedObject, const QTextCharFormat& modifier);
|
|
|
void mergeBlockFormat(QTextCursor* theWrappedObject, const QTextBlockFormat& modifier);
|
|
|
void mergeCharFormat(QTextCursor* theWrappedObject, const QTextCharFormat& modifier);
|
|
|
bool movePosition(QTextCursor* theWrappedObject, QTextCursor::MoveOperation op, QTextCursor::MoveMode arg__2 = QTextCursor::MoveAnchor, int n = 1);
|
|
|
bool __ne__(QTextCursor* theWrappedObject, const QTextCursor& rhs) const;
|
|
|
bool __lt__(QTextCursor* theWrappedObject, const QTextCursor& rhs) const;
|
|
|
bool __le__(QTextCursor* theWrappedObject, const QTextCursor& rhs) const;
|
|
|
bool __eq__(QTextCursor* theWrappedObject, const QTextCursor& rhs) const;
|
|
|
bool __gt__(QTextCursor* theWrappedObject, const QTextCursor& rhs) const;
|
|
|
bool __ge__(QTextCursor* theWrappedObject, const QTextCursor& rhs) const;
|
|
|
int position(QTextCursor* theWrappedObject) const;
|
|
|
int positionInBlock(QTextCursor* theWrappedObject) const;
|
|
|
void removeSelectedText(QTextCursor* theWrappedObject);
|
|
|
void select(QTextCursor* theWrappedObject, QTextCursor::SelectionType selection);
|
|
|
void selectedTableCells(QTextCursor* theWrappedObject, int* firstRow, int* numRows, int* firstColumn, int* numColumns) const;
|
|
|
QString selectedText(QTextCursor* theWrappedObject) const;
|
|
|
QTextDocumentFragment selection(QTextCursor* theWrappedObject) const;
|
|
|
int selectionEnd(QTextCursor* theWrappedObject) const;
|
|
|
int selectionStart(QTextCursor* theWrappedObject) const;
|
|
|
void setBlockCharFormat(QTextCursor* theWrappedObject, const QTextCharFormat& format);
|
|
|
void setBlockFormat(QTextCursor* theWrappedObject, const QTextBlockFormat& format);
|
|
|
void setCharFormat(QTextCursor* theWrappedObject, const QTextCharFormat& format);
|
|
|
void setKeepPositionOnInsert(QTextCursor* theWrappedObject, bool b);
|
|
|
void setPosition(QTextCursor* theWrappedObject, int pos, QTextCursor::MoveMode mode = QTextCursor::MoveAnchor);
|
|
|
void setVerticalMovementX(QTextCursor* theWrappedObject, int x);
|
|
|
void setVisualNavigation(QTextCursor* theWrappedObject, bool b);
|
|
|
int verticalMovementX(QTextCursor* theWrappedObject) const;
|
|
|
bool visualNavigation(QTextCursor* theWrappedObject) const;
|
|
|
bool __nonzero__(QTextCursor* obj) { return !obj->isNull(); }
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextDocument : public QTextDocument
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextDocument(QObject* parent = 0):QTextDocument(parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTextDocument(const QString& text, QObject* parent = 0):QTextDocument(text, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextDocument();
|
|
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void clear();
|
|
|
virtual QTextObject* createObject(const QTextFormat& f);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* arg__1);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual QVariant loadResource(int type, const QUrl& name);
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTextDocument : public QTextDocument
|
|
|
{ public:
|
|
|
inline void promoted_clear() { QTextDocument::clear(); }
|
|
|
inline QTextObject* promoted_createObject(const QTextFormat& f) { return QTextDocument::createObject(f); }
|
|
|
inline QVariant promoted_loadResource(int type, const QUrl& name) { return QTextDocument::loadResource(type, name); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTextDocument : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(ResourceType Stacks FindFlag MetaInformation )
|
|
|
Q_FLAGS(FindFlags )
|
|
|
enum ResourceType{
|
|
|
HtmlResource = QTextDocument::HtmlResource, ImageResource = QTextDocument::ImageResource, StyleSheetResource = QTextDocument::StyleSheetResource, UserResource = QTextDocument::UserResource};
|
|
|
enum Stacks{
|
|
|
UndoStack = QTextDocument::UndoStack, RedoStack = QTextDocument::RedoStack, UndoAndRedoStacks = QTextDocument::UndoAndRedoStacks};
|
|
|
enum FindFlag{
|
|
|
FindBackward = QTextDocument::FindBackward, FindCaseSensitively = QTextDocument::FindCaseSensitively, FindWholeWords = QTextDocument::FindWholeWords};
|
|
|
enum MetaInformation{
|
|
|
DocumentTitle = QTextDocument::DocumentTitle, DocumentUrl = QTextDocument::DocumentUrl};
|
|
|
Q_DECLARE_FLAGS(FindFlags, FindFlag)
|
|
|
public slots:
|
|
|
QTextDocument* new_QTextDocument(QObject* parent = 0);
|
|
|
QTextDocument* new_QTextDocument(const QString& text, QObject* parent = 0);
|
|
|
void delete_QTextDocument(QTextDocument* obj) { delete obj; }
|
|
|
void addResource(QTextDocument* theWrappedObject, int type, const QUrl& name, const QVariant& resource);
|
|
|
void adjustSize(QTextDocument* theWrappedObject);
|
|
|
QVector<QTextFormat > allFormats(QTextDocument* theWrappedObject) const;
|
|
|
int availableRedoSteps(QTextDocument* theWrappedObject) const;
|
|
|
int availableUndoSteps(QTextDocument* theWrappedObject) const;
|
|
|
QTextBlock begin(QTextDocument* theWrappedObject) const;
|
|
|
int blockCount(QTextDocument* theWrappedObject) const;
|
|
|
QChar characterAt(QTextDocument* theWrappedObject, int pos) const;
|
|
|
int characterCount(QTextDocument* theWrappedObject) const;
|
|
|
void clear(QTextDocument* theWrappedObject);
|
|
|
void clearUndoRedoStacks(QTextDocument* theWrappedObject, QTextDocument::Stacks historyToClear = QTextDocument::UndoAndRedoStacks);
|
|
|
QTextDocument* clone(QTextDocument* theWrappedObject, QObject* parent = 0) const;
|
|
|
QTextObject* createObject(QTextDocument* theWrappedObject, const QTextFormat& f);
|
|
|
Qt::CursorMoveStyle defaultCursorMoveStyle(QTextDocument* theWrappedObject) const;
|
|
|
QFont defaultFont(QTextDocument* theWrappedObject) const;
|
|
|
QString defaultStyleSheet(QTextDocument* theWrappedObject) const;
|
|
|
QTextOption defaultTextOption(QTextDocument* theWrappedObject) const;
|
|
|
QAbstractTextDocumentLayout* documentLayout(QTextDocument* theWrappedObject) const;
|
|
|
qreal documentMargin(QTextDocument* theWrappedObject) const;
|
|
|
void drawContents(QTextDocument* theWrappedObject, QPainter* painter, const QRectF& rect = QRectF());
|
|
|
QTextBlock end(QTextDocument* theWrappedObject) const;
|
|
|
QTextCursor find(QTextDocument* theWrappedObject, const QRegExp& expr, const QTextCursor& from, QTextDocument::FindFlags options = 0) const;
|
|
|
QTextCursor find(QTextDocument* theWrappedObject, const QRegExp& expr, int from = 0, QTextDocument::FindFlags options = 0) const;
|
|
|
QTextCursor find(QTextDocument* theWrappedObject, const QString& subString, const QTextCursor& from, QTextDocument::FindFlags options = 0) const;
|
|
|
QTextCursor find(QTextDocument* theWrappedObject, const QString& subString, int from = 0, QTextDocument::FindFlags options = 0) const;
|
|
|
QTextBlock findBlock(QTextDocument* theWrappedObject, int pos) const;
|
|
|
QTextBlock findBlockByLineNumber(QTextDocument* theWrappedObject, int blockNumber) const;
|
|
|
QTextBlock findBlockByNumber(QTextDocument* theWrappedObject, int blockNumber) const;
|
|
|
QTextBlock firstBlock(QTextDocument* theWrappedObject) const;
|
|
|
QTextFrame* frameAt(QTextDocument* theWrappedObject, int pos) const;
|
|
|
qreal idealWidth(QTextDocument* theWrappedObject) const;
|
|
|
qreal indentWidth(QTextDocument* theWrappedObject) const;
|
|
|
bool isEmpty(QTextDocument* theWrappedObject) const;
|
|
|
bool isModified(QTextDocument* theWrappedObject) const;
|
|
|
bool isRedoAvailable(QTextDocument* theWrappedObject) const;
|
|
|
bool isUndoAvailable(QTextDocument* theWrappedObject) const;
|
|
|
bool isUndoRedoEnabled(QTextDocument* theWrappedObject) const;
|
|
|
QTextBlock lastBlock(QTextDocument* theWrappedObject) const;
|
|
|
int lineCount(QTextDocument* theWrappedObject) const;
|
|
|
QVariant loadResource(QTextDocument* theWrappedObject, int type, const QUrl& name);
|
|
|
void markContentsDirty(QTextDocument* theWrappedObject, int from, int length);
|
|
|
int maximumBlockCount(QTextDocument* theWrappedObject) const;
|
|
|
QString metaInformation(QTextDocument* theWrappedObject, QTextDocument::MetaInformation info) const;
|
|
|
QTextObject* object(QTextDocument* theWrappedObject, int objectIndex) const;
|
|
|
QTextObject* objectForFormat(QTextDocument* theWrappedObject, const QTextFormat& arg__1) const;
|
|
|
int pageCount(QTextDocument* theWrappedObject) const;
|
|
|
QSizeF pageSize(QTextDocument* theWrappedObject) const;
|
|
|
void print(QTextDocument* theWrappedObject, QPrinter* printer) const;
|
|
|
void redo(QTextDocument* theWrappedObject, QTextCursor* cursor);
|
|
|
QVariant resource(QTextDocument* theWrappedObject, int type, const QUrl& name) const;
|
|
|
int revision(QTextDocument* theWrappedObject) const;
|
|
|
QTextFrame* rootFrame(QTextDocument* theWrappedObject) const;
|
|
|
void setDefaultCursorMoveStyle(QTextDocument* theWrappedObject, Qt::CursorMoveStyle style);
|
|
|
void setDefaultFont(QTextDocument* theWrappedObject, const QFont& font);
|
|
|
void setDefaultStyleSheet(QTextDocument* theWrappedObject, const QString& sheet);
|
|
|
void setDefaultTextOption(QTextDocument* theWrappedObject, const QTextOption& option);
|
|
|
void setDocumentLayout(QTextDocument* theWrappedObject, QAbstractTextDocumentLayout* layout);
|
|
|
void setDocumentMargin(QTextDocument* theWrappedObject, qreal margin);
|
|
|
void setHtml(QTextDocument* theWrappedObject, const QString& html);
|
|
|
void setIndentWidth(QTextDocument* theWrappedObject, qreal width);
|
|
|
void setMaximumBlockCount(QTextDocument* theWrappedObject, int maximum);
|
|
|
void setMetaInformation(QTextDocument* theWrappedObject, QTextDocument::MetaInformation info, const QString& arg__2);
|
|
|
void setPageSize(QTextDocument* theWrappedObject, const QSizeF& size);
|
|
|
void setPlainText(QTextDocument* theWrappedObject, const QString& text);
|
|
|
void setTextWidth(QTextDocument* theWrappedObject, qreal width);
|
|
|
void setUndoRedoEnabled(QTextDocument* theWrappedObject, bool enable);
|
|
|
void setUseDesignMetrics(QTextDocument* theWrappedObject, bool b);
|
|
|
QSizeF size(QTextDocument* theWrappedObject) const;
|
|
|
qreal textWidth(QTextDocument* theWrappedObject) const;
|
|
|
QString toHtml(QTextDocument* theWrappedObject, const QByteArray& encoding = QByteArray()) const;
|
|
|
QString toPlainText(QTextDocument* theWrappedObject) const;
|
|
|
void undo(QTextDocument* theWrappedObject, QTextCursor* cursor);
|
|
|
bool useDesignMetrics(QTextDocument* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QTextDocumentFragment : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTextDocumentFragment* new_QTextDocumentFragment();
|
|
|
QTextDocumentFragment* new_QTextDocumentFragment(const QTextCursor& range);
|
|
|
QTextDocumentFragment* new_QTextDocumentFragment(const QTextDocument* document);
|
|
|
QTextDocumentFragment* new_QTextDocumentFragment(const QTextDocumentFragment& rhs);
|
|
|
void delete_QTextDocumentFragment(QTextDocumentFragment* obj) { delete obj; }
|
|
|
QTextDocumentFragment static_QTextDocumentFragment_fromHtml(const QString& html);
|
|
|
QTextDocumentFragment static_QTextDocumentFragment_fromHtml(const QString& html, const QTextDocument* resourceProvider);
|
|
|
QTextDocumentFragment static_QTextDocumentFragment_fromPlainText(const QString& plainText);
|
|
|
bool isEmpty(QTextDocumentFragment* theWrappedObject) const;
|
|
|
QString toHtml(QTextDocumentFragment* theWrappedObject) const;
|
|
|
QString toHtml(QTextDocumentFragment* theWrappedObject, const QByteArray& encoding) const;
|
|
|
QString toPlainText(QTextDocumentFragment* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QTextDocumentWriter : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTextDocumentWriter* new_QTextDocumentWriter();
|
|
|
QTextDocumentWriter* new_QTextDocumentWriter(QIODevice* device, const QByteArray& format);
|
|
|
QTextDocumentWriter* new_QTextDocumentWriter(const QString& fileName, const QByteArray& format = QByteArray());
|
|
|
void delete_QTextDocumentWriter(QTextDocumentWriter* obj) { delete obj; }
|
|
|
QTextCodec* codec(QTextDocumentWriter* theWrappedObject) const;
|
|
|
QIODevice* device(QTextDocumentWriter* theWrappedObject) const;
|
|
|
QString fileName(QTextDocumentWriter* theWrappedObject) const;
|
|
|
QByteArray format(QTextDocumentWriter* theWrappedObject) const;
|
|
|
void setCodec(QTextDocumentWriter* theWrappedObject, QTextCodec* codec);
|
|
|
void setDevice(QTextDocumentWriter* theWrappedObject, QIODevice* device);
|
|
|
void setFileName(QTextDocumentWriter* theWrappedObject, const QString& fileName);
|
|
|
void setFormat(QTextDocumentWriter* theWrappedObject, const QByteArray& format);
|
|
|
QList<QByteArray > static_QTextDocumentWriter_supportedDocumentFormats();
|
|
|
bool write(QTextDocumentWriter* theWrappedObject, const QTextDocument* document);
|
|
|
bool write(QTextDocumentWriter* theWrappedObject, const QTextDocumentFragment& fragment);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextEdit : public QTextEdit
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextEdit(QWidget* parent = 0):QTextEdit(parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTextEdit(const QString& text, QWidget* parent = 0):QTextEdit(text, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextEdit();
|
|
|
|
|
|
virtual void actionEvent(QActionEvent* arg__1);
|
|
|
virtual bool canInsertFromMimeData(const QMimeData* source) const;
|
|
|
virtual void changeEvent(QEvent* e);
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void closeEvent(QCloseEvent* arg__1);
|
|
|
virtual void contextMenuEvent(QContextMenuEvent* e);
|
|
|
virtual QMimeData* createMimeDataFromSelection() const;
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual int devType() const;
|
|
|
virtual void dragEnterEvent(QDragEnterEvent* e);
|
|
|
virtual void dragLeaveEvent(QDragLeaveEvent* e);
|
|
|
virtual void dragMoveEvent(QDragMoveEvent* e);
|
|
|
virtual void dropEvent(QDropEvent* e);
|
|
|
virtual void enterEvent(QEvent* arg__1);
|
|
|
virtual bool event(QEvent* e);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual void focusInEvent(QFocusEvent* e);
|
|
|
virtual bool focusNextPrevChild(bool next);
|
|
|
virtual void focusOutEvent(QFocusEvent* e);
|
|
|
virtual int heightForWidth(int arg__1) const;
|
|
|
virtual void hideEvent(QHideEvent* arg__1);
|
|
|
virtual void inputMethodEvent(QInputMethodEvent* arg__1);
|
|
|
virtual QVariant inputMethodQuery(Qt::InputMethodQuery property) const;
|
|
|
virtual void insertFromMimeData(const QMimeData* source);
|
|
|
virtual void keyPressEvent(QKeyEvent* e);
|
|
|
virtual void keyReleaseEvent(QKeyEvent* e);
|
|
|
virtual void languageChange();
|
|
|
virtual void leaveEvent(QEvent* arg__1);
|
|
|
virtual QVariant loadResource(int type, const QUrl& name);
|
|
|
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 QPaintEngine* paintEngine() const;
|
|
|
virtual void paintEvent(QPaintEvent* e);
|
|
|
virtual void resizeEvent(QResizeEvent* e);
|
|
|
virtual void scrollContentsBy(int dx, int dy);
|
|
|
virtual void showEvent(QShowEvent* arg__1);
|
|
|
virtual void tabletEvent(QTabletEvent* arg__1);
|
|
|
virtual void timerEvent(QTimerEvent* e);
|
|
|
virtual bool viewportEvent(QEvent* arg__1);
|
|
|
virtual void wheelEvent(QWheelEvent* e);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTextEdit : public QTextEdit
|
|
|
{ public:
|
|
|
inline bool promoted_canInsertFromMimeData(const QMimeData* source) const { return QTextEdit::canInsertFromMimeData(source); }
|
|
|
inline void promoted_changeEvent(QEvent* e) { QTextEdit::changeEvent(e); }
|
|
|
inline void promoted_contextMenuEvent(QContextMenuEvent* e) { QTextEdit::contextMenuEvent(e); }
|
|
|
inline QMimeData* promoted_createMimeDataFromSelection() const { return QTextEdit::createMimeDataFromSelection(); }
|
|
|
inline void promoted_dragEnterEvent(QDragEnterEvent* e) { QTextEdit::dragEnterEvent(e); }
|
|
|
inline void promoted_dragLeaveEvent(QDragLeaveEvent* e) { QTextEdit::dragLeaveEvent(e); }
|
|
|
inline void promoted_dragMoveEvent(QDragMoveEvent* e) { QTextEdit::dragMoveEvent(e); }
|
|
|
inline void promoted_dropEvent(QDropEvent* e) { QTextEdit::dropEvent(e); }
|
|
|
inline bool promoted_event(QEvent* e) { return QTextEdit::event(e); }
|
|
|
inline void promoted_focusInEvent(QFocusEvent* e) { QTextEdit::focusInEvent(e); }
|
|
|
inline bool promoted_focusNextPrevChild(bool next) { return QTextEdit::focusNextPrevChild(next); }
|
|
|
inline void promoted_focusOutEvent(QFocusEvent* e) { QTextEdit::focusOutEvent(e); }
|
|
|
inline void promoted_inputMethodEvent(QInputMethodEvent* arg__1) { QTextEdit::inputMethodEvent(arg__1); }
|
|
|
inline QVariant promoted_inputMethodQuery(Qt::InputMethodQuery property) const { return QTextEdit::inputMethodQuery(property); }
|
|
|
inline void promoted_insertFromMimeData(const QMimeData* source) { QTextEdit::insertFromMimeData(source); }
|
|
|
inline void promoted_keyPressEvent(QKeyEvent* e) { QTextEdit::keyPressEvent(e); }
|
|
|
inline void promoted_keyReleaseEvent(QKeyEvent* e) { QTextEdit::keyReleaseEvent(e); }
|
|
|
inline QVariant promoted_loadResource(int type, const QUrl& name) { return QTextEdit::loadResource(type, name); }
|
|
|
inline void promoted_mouseDoubleClickEvent(QMouseEvent* e) { QTextEdit::mouseDoubleClickEvent(e); }
|
|
|
inline void promoted_mouseMoveEvent(QMouseEvent* e) { QTextEdit::mouseMoveEvent(e); }
|
|
|
inline void promoted_mousePressEvent(QMouseEvent* e) { QTextEdit::mousePressEvent(e); }
|
|
|
inline void promoted_mouseReleaseEvent(QMouseEvent* e) { QTextEdit::mouseReleaseEvent(e); }
|
|
|
inline void promoted_paintEvent(QPaintEvent* e) { QTextEdit::paintEvent(e); }
|
|
|
inline void promoted_resizeEvent(QResizeEvent* e) { QTextEdit::resizeEvent(e); }
|
|
|
inline void promoted_scrollContentsBy(int dx, int dy) { QTextEdit::scrollContentsBy(dx, dy); }
|
|
|
inline void promoted_showEvent(QShowEvent* arg__1) { QTextEdit::showEvent(arg__1); }
|
|
|
inline void promoted_timerEvent(QTimerEvent* e) { QTextEdit::timerEvent(e); }
|
|
|
inline void promoted_wheelEvent(QWheelEvent* e) { QTextEdit::wheelEvent(e); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTextEdit : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(AutoFormattingFlag )
|
|
|
Q_FLAGS(AutoFormatting )
|
|
|
enum AutoFormattingFlag{
|
|
|
AutoNone = QTextEdit::AutoNone, AutoBulletList = QTextEdit::AutoBulletList, AutoAll = QTextEdit::AutoAll};
|
|
|
Q_DECLARE_FLAGS(AutoFormatting, AutoFormattingFlag)
|
|
|
public slots:
|
|
|
QTextEdit* new_QTextEdit(QWidget* parent = 0);
|
|
|
QTextEdit* new_QTextEdit(const QString& text, QWidget* parent = 0);
|
|
|
void delete_QTextEdit(QTextEdit* obj) { delete obj; }
|
|
|
bool acceptRichText(QTextEdit* theWrappedObject) const;
|
|
|
Qt::Alignment alignment(QTextEdit* theWrappedObject) const;
|
|
|
QString anchorAt(QTextEdit* theWrappedObject, const QPoint& pos) const;
|
|
|
QTextEdit::AutoFormatting autoFormatting(QTextEdit* theWrappedObject) const;
|
|
|
bool canInsertFromMimeData(QTextEdit* theWrappedObject, const QMimeData* source) const;
|
|
|
bool canPaste(QTextEdit* theWrappedObject) const;
|
|
|
void changeEvent(QTextEdit* theWrappedObject, QEvent* e);
|
|
|
void contextMenuEvent(QTextEdit* theWrappedObject, QContextMenuEvent* e);
|
|
|
QMimeData* createMimeDataFromSelection(QTextEdit* theWrappedObject) const;
|
|
|
QMenu* createStandardContextMenu(QTextEdit* theWrappedObject);
|
|
|
QMenu* createStandardContextMenu(QTextEdit* theWrappedObject, const QPoint& position);
|
|
|
QTextCharFormat currentCharFormat(QTextEdit* theWrappedObject) const;
|
|
|
QFont currentFont(QTextEdit* theWrappedObject) const;
|
|
|
QTextCursor cursorForPosition(QTextEdit* theWrappedObject, const QPoint& pos) const;
|
|
|
QRect cursorRect(QTextEdit* theWrappedObject) const;
|
|
|
QRect cursorRect(QTextEdit* theWrappedObject, const QTextCursor& cursor) const;
|
|
|
int cursorWidth(QTextEdit* theWrappedObject) const;
|
|
|
QTextDocument* document(QTextEdit* theWrappedObject) const;
|
|
|
QString documentTitle(QTextEdit* theWrappedObject) const;
|
|
|
void dragEnterEvent(QTextEdit* theWrappedObject, QDragEnterEvent* e);
|
|
|
void dragLeaveEvent(QTextEdit* theWrappedObject, QDragLeaveEvent* e);
|
|
|
void dragMoveEvent(QTextEdit* theWrappedObject, QDragMoveEvent* e);
|
|
|
void dropEvent(QTextEdit* theWrappedObject, QDropEvent* e);
|
|
|
void ensureCursorVisible(QTextEdit* theWrappedObject);
|
|
|
bool event(QTextEdit* theWrappedObject, QEvent* e);
|
|
|
QList<QTextEdit::ExtraSelection > extraSelections(QTextEdit* theWrappedObject) const;
|
|
|
bool find(QTextEdit* theWrappedObject, const QString& exp, QTextDocument::FindFlags options = 0);
|
|
|
void focusInEvent(QTextEdit* theWrappedObject, QFocusEvent* e);
|
|
|
bool focusNextPrevChild(QTextEdit* theWrappedObject, bool next);
|
|
|
void focusOutEvent(QTextEdit* theWrappedObject, QFocusEvent* e);
|
|
|
QString fontFamily(QTextEdit* theWrappedObject) const;
|
|
|
bool fontItalic(QTextEdit* theWrappedObject) const;
|
|
|
qreal fontPointSize(QTextEdit* theWrappedObject) const;
|
|
|
bool fontUnderline(QTextEdit* theWrappedObject) const;
|
|
|
int fontWeight(QTextEdit* theWrappedObject) const;
|
|
|
void inputMethodEvent(QTextEdit* theWrappedObject, QInputMethodEvent* arg__1);
|
|
|
QVariant inputMethodQuery(QTextEdit* theWrappedObject, Qt::InputMethodQuery property) const;
|
|
|
void insertFromMimeData(QTextEdit* theWrappedObject, const QMimeData* source);
|
|
|
bool isReadOnly(QTextEdit* theWrappedObject) const;
|
|
|
bool isUndoRedoEnabled(QTextEdit* theWrappedObject) const;
|
|
|
void keyPressEvent(QTextEdit* theWrappedObject, QKeyEvent* e);
|
|
|
void keyReleaseEvent(QTextEdit* theWrappedObject, QKeyEvent* e);
|
|
|
int lineWrapColumnOrWidth(QTextEdit* theWrappedObject) const;
|
|
|
QTextEdit::LineWrapMode lineWrapMode(QTextEdit* theWrappedObject) const;
|
|
|
QVariant loadResource(QTextEdit* theWrappedObject, int type, const QUrl& name);
|
|
|
void mergeCurrentCharFormat(QTextEdit* theWrappedObject, const QTextCharFormat& modifier);
|
|
|
void mouseDoubleClickEvent(QTextEdit* theWrappedObject, QMouseEvent* e);
|
|
|
void mouseMoveEvent(QTextEdit* theWrappedObject, QMouseEvent* e);
|
|
|
void mousePressEvent(QTextEdit* theWrappedObject, QMouseEvent* e);
|
|
|
void mouseReleaseEvent(QTextEdit* theWrappedObject, QMouseEvent* e);
|
|
|
void moveCursor(QTextEdit* theWrappedObject, QTextCursor::MoveOperation operation, QTextCursor::MoveMode mode = QTextCursor::MoveAnchor);
|
|
|
bool overwriteMode(QTextEdit* theWrappedObject) const;
|
|
|
void paintEvent(QTextEdit* theWrappedObject, QPaintEvent* e);
|
|
|
void print(QTextEdit* theWrappedObject, QPrinter* printer) const;
|
|
|
void resizeEvent(QTextEdit* theWrappedObject, QResizeEvent* e);
|
|
|
void scrollContentsBy(QTextEdit* theWrappedObject, int dx, int dy);
|
|
|
void setAcceptRichText(QTextEdit* theWrappedObject, bool accept);
|
|
|
void setAutoFormatting(QTextEdit* theWrappedObject, QTextEdit::AutoFormatting features);
|
|
|
void setCurrentCharFormat(QTextEdit* theWrappedObject, const QTextCharFormat& format);
|
|
|
void setCursorWidth(QTextEdit* theWrappedObject, int width);
|
|
|
void setDocument(QTextEdit* theWrappedObject, QTextDocument* document);
|
|
|
void setDocumentTitle(QTextEdit* theWrappedObject, const QString& title);
|
|
|
void setExtraSelections(QTextEdit* theWrappedObject, const QList<QTextEdit::ExtraSelection >& selections);
|
|
|
void setLineWrapColumnOrWidth(QTextEdit* theWrappedObject, int w);
|
|
|
void setLineWrapMode(QTextEdit* theWrappedObject, QTextEdit::LineWrapMode mode);
|
|
|
void setOverwriteMode(QTextEdit* theWrappedObject, bool overwrite);
|
|
|
void setReadOnly(QTextEdit* theWrappedObject, bool ro);
|
|
|
void setTabChangesFocus(QTextEdit* theWrappedObject, bool b);
|
|
|
void setTabStopWidth(QTextEdit* theWrappedObject, int width);
|
|
|
void setTextCursor(QTextEdit* theWrappedObject, const QTextCursor& cursor);
|
|
|
void setTextInteractionFlags(QTextEdit* theWrappedObject, Qt::TextInteractionFlags flags);
|
|
|
void setUndoRedoEnabled(QTextEdit* theWrappedObject, bool enable);
|
|
|
void setWordWrapMode(QTextEdit* theWrappedObject, QTextOption::WrapMode policy);
|
|
|
void showEvent(QTextEdit* theWrappedObject, QShowEvent* arg__1);
|
|
|
bool tabChangesFocus(QTextEdit* theWrappedObject) const;
|
|
|
int tabStopWidth(QTextEdit* theWrappedObject) const;
|
|
|
QColor textBackgroundColor(QTextEdit* theWrappedObject) const;
|
|
|
QColor textColor(QTextEdit* theWrappedObject) const;
|
|
|
QTextCursor textCursor(QTextEdit* theWrappedObject) const;
|
|
|
Qt::TextInteractionFlags textInteractionFlags(QTextEdit* theWrappedObject) const;
|
|
|
void timerEvent(QTextEdit* theWrappedObject, QTimerEvent* e);
|
|
|
QString toHtml(QTextEdit* theWrappedObject) const;
|
|
|
QString toPlainText(QTextEdit* theWrappedObject) const;
|
|
|
void wheelEvent(QTextEdit* theWrappedObject, QWheelEvent* e);
|
|
|
QTextOption::WrapMode wordWrapMode(QTextEdit* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QTextFragment : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTextFragment* new_QTextFragment();
|
|
|
QTextFragment* new_QTextFragment(const QTextFragment& o);
|
|
|
void delete_QTextFragment(QTextFragment* obj) { delete obj; }
|
|
|
QTextCharFormat charFormat(QTextFragment* theWrappedObject) const;
|
|
|
int charFormatIndex(QTextFragment* theWrappedObject) const;
|
|
|
bool contains(QTextFragment* theWrappedObject, int position) const;
|
|
|
bool isValid(QTextFragment* theWrappedObject) const;
|
|
|
int length(QTextFragment* theWrappedObject) const;
|
|
|
bool __ne__(QTextFragment* theWrappedObject, const QTextFragment& o) const;
|
|
|
bool __lt__(QTextFragment* theWrappedObject, const QTextFragment& o) const;
|
|
|
bool __eq__(QTextFragment* theWrappedObject, const QTextFragment& o) const;
|
|
|
int position(QTextFragment* theWrappedObject) const;
|
|
|
QString text(QTextFragment* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextFrame : public QTextFrame
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextFrame(QTextDocument* doc):QTextFrame(doc),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextFrame();
|
|
|
|
|
|
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_QTextFrame : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTextFrame* new_QTextFrame(QTextDocument* doc);
|
|
|
void delete_QTextFrame(QTextFrame* obj) { delete obj; }
|
|
|
QTextFrame::iterator begin(QTextFrame* theWrappedObject) const;
|
|
|
QList<QTextFrame* > childFrames(QTextFrame* theWrappedObject) const;
|
|
|
QTextFrame::iterator end(QTextFrame* theWrappedObject) const;
|
|
|
QTextCursor firstCursorPosition(QTextFrame* theWrappedObject) const;
|
|
|
int firstPosition(QTextFrame* theWrappedObject) const;
|
|
|
QTextFrameFormat frameFormat(QTextFrame* theWrappedObject) const;
|
|
|
QTextCursor lastCursorPosition(QTextFrame* theWrappedObject) const;
|
|
|
int lastPosition(QTextFrame* theWrappedObject) const;
|
|
|
QTextFrame* parentFrame(QTextFrame* theWrappedObject) const;
|
|
|
void setFrameFormat(QTextFrame* theWrappedObject, const QTextFrameFormat& format);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextFrameFormat : public QTextFrameFormat
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextFrameFormat():QTextFrameFormat(),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTextFrameFormat(const QTextFormat& fmt):QTextFrameFormat(fmt),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextFrameFormat();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTextFrameFormat : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(Position BorderStyle )
|
|
|
enum Position{
|
|
|
InFlow = QTextFrameFormat::InFlow, FloatLeft = QTextFrameFormat::FloatLeft, FloatRight = QTextFrameFormat::FloatRight};
|
|
|
enum BorderStyle{
|
|
|
BorderStyle_None = QTextFrameFormat::BorderStyle_None, BorderStyle_Dotted = QTextFrameFormat::BorderStyle_Dotted, BorderStyle_Dashed = QTextFrameFormat::BorderStyle_Dashed, BorderStyle_Solid = QTextFrameFormat::BorderStyle_Solid, BorderStyle_Double = QTextFrameFormat::BorderStyle_Double, BorderStyle_DotDash = QTextFrameFormat::BorderStyle_DotDash, BorderStyle_DotDotDash = QTextFrameFormat::BorderStyle_DotDotDash, BorderStyle_Groove = QTextFrameFormat::BorderStyle_Groove, BorderStyle_Ridge = QTextFrameFormat::BorderStyle_Ridge, BorderStyle_Inset = QTextFrameFormat::BorderStyle_Inset, BorderStyle_Outset = QTextFrameFormat::BorderStyle_Outset};
|
|
|
public slots:
|
|
|
QTextFrameFormat* new_QTextFrameFormat();
|
|
|
QTextFrameFormat* new_QTextFrameFormat(const QTextFrameFormat& other) {
|
|
|
PythonQtShell_QTextFrameFormat* a = new PythonQtShell_QTextFrameFormat();
|
|
|
*((QTextFrameFormat*)a) = other;
|
|
|
return a; }
|
|
|
void delete_QTextFrameFormat(QTextFrameFormat* obj) { delete obj; }
|
|
|
qreal border(QTextFrameFormat* theWrappedObject) const;
|
|
|
QBrush borderBrush(QTextFrameFormat* theWrappedObject) const;
|
|
|
QTextFrameFormat::BorderStyle borderStyle(QTextFrameFormat* theWrappedObject) const;
|
|
|
qreal bottomMargin(QTextFrameFormat* theWrappedObject) const;
|
|
|
QTextLength height(QTextFrameFormat* theWrappedObject) const;
|
|
|
bool isValid(QTextFrameFormat* theWrappedObject) const;
|
|
|
qreal leftMargin(QTextFrameFormat* theWrappedObject) const;
|
|
|
qreal margin(QTextFrameFormat* theWrappedObject) const;
|
|
|
qreal padding(QTextFrameFormat* theWrappedObject) const;
|
|
|
QTextFormat::PageBreakFlags pageBreakPolicy(QTextFrameFormat* theWrappedObject) const;
|
|
|
QTextFrameFormat::Position position(QTextFrameFormat* theWrappedObject) const;
|
|
|
qreal rightMargin(QTextFrameFormat* theWrappedObject) const;
|
|
|
void setBorder(QTextFrameFormat* theWrappedObject, qreal border);
|
|
|
void setBorderBrush(QTextFrameFormat* theWrappedObject, const QBrush& brush);
|
|
|
void setBorderStyle(QTextFrameFormat* theWrappedObject, QTextFrameFormat::BorderStyle style);
|
|
|
void setBottomMargin(QTextFrameFormat* theWrappedObject, qreal margin);
|
|
|
void setHeight(QTextFrameFormat* theWrappedObject, const QTextLength& height);
|
|
|
void setHeight(QTextFrameFormat* theWrappedObject, qreal height);
|
|
|
void setLeftMargin(QTextFrameFormat* theWrappedObject, qreal margin);
|
|
|
void setMargin(QTextFrameFormat* theWrappedObject, qreal margin);
|
|
|
void setPadding(QTextFrameFormat* theWrappedObject, qreal padding);
|
|
|
void setPageBreakPolicy(QTextFrameFormat* theWrappedObject, QTextFormat::PageBreakFlags flags);
|
|
|
void setPosition(QTextFrameFormat* theWrappedObject, QTextFrameFormat::Position f);
|
|
|
void setRightMargin(QTextFrameFormat* theWrappedObject, qreal margin);
|
|
|
void setTopMargin(QTextFrameFormat* theWrappedObject, qreal margin);
|
|
|
void setWidth(QTextFrameFormat* theWrappedObject, const QTextLength& length);
|
|
|
void setWidth(QTextFrameFormat* theWrappedObject, qreal width);
|
|
|
qreal topMargin(QTextFrameFormat* theWrappedObject) const;
|
|
|
QTextLength width(QTextFrameFormat* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextImageFormat : public QTextImageFormat
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextImageFormat():QTextImageFormat(),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTextImageFormat(const QTextFormat& format):QTextImageFormat(format),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextImageFormat();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTextImageFormat : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTextImageFormat* new_QTextImageFormat();
|
|
|
QTextImageFormat* new_QTextImageFormat(const QTextImageFormat& other) {
|
|
|
PythonQtShell_QTextImageFormat* a = new PythonQtShell_QTextImageFormat();
|
|
|
*((QTextImageFormat*)a) = other;
|
|
|
return a; }
|
|
|
void delete_QTextImageFormat(QTextImageFormat* obj) { delete obj; }
|
|
|
qreal height(QTextImageFormat* theWrappedObject) const;
|
|
|
bool isValid(QTextImageFormat* theWrappedObject) const;
|
|
|
QString name(QTextImageFormat* theWrappedObject) const;
|
|
|
void setHeight(QTextImageFormat* theWrappedObject, qreal height);
|
|
|
void setName(QTextImageFormat* theWrappedObject, const QString& name);
|
|
|
void setWidth(QTextImageFormat* theWrappedObject, qreal width);
|
|
|
qreal width(QTextImageFormat* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
