#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "gen_qlistview.h" #ifndef _Bool #define _Bool bool #endif #include "_cgo_export.h" class MiqtVirtualQListView : public virtual QListView { public: MiqtVirtualQListView(QWidget* parent): QListView(parent) {}; MiqtVirtualQListView(): QListView() {}; virtual ~MiqtVirtualQListView() = default; // cgo.Handle value for overwritten implementation intptr_t handle__VisualRect = 0; // Subclass to allow providing a Go implementation virtual QRect visualRect(const QModelIndex& index) const override { if (handle__VisualRect == 0) { return QListView::visualRect(index); } const QModelIndex& index_ret = index; // Cast returned reference into pointer QModelIndex* sigval1 = const_cast(&index_ret); QRect* callback_return_value = miqt_exec_callback_QListView_VisualRect(const_cast(this), handle__VisualRect, sigval1); return *callback_return_value; } // Wrapper to allow calling protected method QRect* virtualbase_VisualRect(QModelIndex* index) const { return new QRect(QListView::visualRect(*index)); } // cgo.Handle value for overwritten implementation intptr_t handle__ScrollTo = 0; // Subclass to allow providing a Go implementation virtual void scrollTo(const QModelIndex& index, QAbstractItemView::ScrollHint hint) override { if (handle__ScrollTo == 0) { QListView::scrollTo(index, hint); return; } const QModelIndex& index_ret = index; // Cast returned reference into pointer QModelIndex* sigval1 = const_cast(&index_ret); QAbstractItemView::ScrollHint hint_ret = hint; int sigval2 = static_cast(hint_ret); miqt_exec_callback_QListView_ScrollTo(this, handle__ScrollTo, sigval1, sigval2); } // Wrapper to allow calling protected method void virtualbase_ScrollTo(QModelIndex* index, int hint) { QListView::scrollTo(*index, static_cast(hint)); } // cgo.Handle value for overwritten implementation intptr_t handle__IndexAt = 0; // Subclass to allow providing a Go implementation virtual QModelIndex indexAt(const QPoint& p) const override { if (handle__IndexAt == 0) { return QListView::indexAt(p); } const QPoint& p_ret = p; // Cast returned reference into pointer QPoint* sigval1 = const_cast(&p_ret); QModelIndex* callback_return_value = miqt_exec_callback_QListView_IndexAt(const_cast(this), handle__IndexAt, sigval1); return *callback_return_value; } // Wrapper to allow calling protected method QModelIndex* virtualbase_IndexAt(QPoint* p) const { return new QModelIndex(QListView::indexAt(*p)); } // cgo.Handle value for overwritten implementation intptr_t handle__DoItemsLayout = 0; // Subclass to allow providing a Go implementation virtual void doItemsLayout() override { if (handle__DoItemsLayout == 0) { QListView::doItemsLayout(); return; } miqt_exec_callback_QListView_DoItemsLayout(this, handle__DoItemsLayout); } // Wrapper to allow calling protected method void virtualbase_DoItemsLayout() { QListView::doItemsLayout(); } // cgo.Handle value for overwritten implementation intptr_t handle__Reset = 0; // Subclass to allow providing a Go implementation virtual void reset() override { if (handle__Reset == 0) { QListView::reset(); return; } miqt_exec_callback_QListView_Reset(this, handle__Reset); } // Wrapper to allow calling protected method void virtualbase_Reset() { QListView::reset(); } // cgo.Handle value for overwritten implementation intptr_t handle__SetRootIndex = 0; // Subclass to allow providing a Go implementation virtual void setRootIndex(const QModelIndex& index) override { if (handle__SetRootIndex == 0) { QListView::setRootIndex(index); return; } const QModelIndex& index_ret = index; // Cast returned reference into pointer QModelIndex* sigval1 = const_cast(&index_ret); miqt_exec_callback_QListView_SetRootIndex(this, handle__SetRootIndex, sigval1); } // Wrapper to allow calling protected method void virtualbase_SetRootIndex(QModelIndex* index) { QListView::setRootIndex(*index); } // cgo.Handle value for overwritten implementation intptr_t handle__Event = 0; // Subclass to allow providing a Go implementation virtual bool event(QEvent* e) override { if (handle__Event == 0) { return QListView::event(e); } QEvent* sigval1 = e; bool callback_return_value = miqt_exec_callback_QListView_Event(this, handle__Event, sigval1); return callback_return_value; } // Wrapper to allow calling protected method bool virtualbase_Event(QEvent* e) { return QListView::event(e); } // cgo.Handle value for overwritten implementation intptr_t handle__ScrollContentsBy = 0; // Subclass to allow providing a Go implementation virtual void scrollContentsBy(int dx, int dy) override { if (handle__ScrollContentsBy == 0) { QListView::scrollContentsBy(dx, dy); return; } int sigval1 = dx; int sigval2 = dy; miqt_exec_callback_QListView_ScrollContentsBy(this, handle__ScrollContentsBy, sigval1, sigval2); } // Wrapper to allow calling protected method void virtualbase_ScrollContentsBy(int dx, int dy) { QListView::scrollContentsBy(static_cast(dx), static_cast(dy)); } // cgo.Handle value for overwritten implementation intptr_t handle__DataChanged = 0; // Subclass to allow providing a Go implementation virtual void dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector& roles) override { if (handle__DataChanged == 0) { QListView::dataChanged(topLeft, bottomRight, roles); return; } const QModelIndex& topLeft_ret = topLeft; // Cast returned reference into pointer QModelIndex* sigval1 = const_cast(&topLeft_ret); const QModelIndex& bottomRight_ret = bottomRight; // Cast returned reference into pointer QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QVector& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; roles_out.len = roles_ret.length(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QListView_DataChanged(this, handle__DataChanged, sigval1, sigval2, sigval3); } // Wrapper to allow calling protected method void virtualbase_DataChanged(QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { QVector roles_QList; roles_QList.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { roles_QList.push_back(static_cast(roles_arr[i])); } QListView::dataChanged(*topLeft, *bottomRight, roles_QList); } // cgo.Handle value for overwritten implementation intptr_t handle__RowsInserted = 0; // Subclass to allow providing a Go implementation virtual void rowsInserted(const QModelIndex& parent, int start, int end) override { if (handle__RowsInserted == 0) { QListView::rowsInserted(parent, start, end); return; } const QModelIndex& parent_ret = parent; // Cast returned reference into pointer QModelIndex* sigval1 = const_cast(&parent_ret); int sigval2 = start; int sigval3 = end; miqt_exec_callback_QListView_RowsInserted(this, handle__RowsInserted, sigval1, sigval2, sigval3); } // Wrapper to allow calling protected method void virtualbase_RowsInserted(QModelIndex* parent, int start, int end) { QListView::rowsInserted(*parent, static_cast(start), static_cast(end)); } // cgo.Handle value for overwritten implementation intptr_t handle__RowsAboutToBeRemoved = 0; // Subclass to allow providing a Go implementation virtual void rowsAboutToBeRemoved(const QModelIndex& parent, int start, int end) override { if (handle__RowsAboutToBeRemoved == 0) { QListView::rowsAboutToBeRemoved(parent, start, end); return; } const QModelIndex& parent_ret = parent; // Cast returned reference into pointer QModelIndex* sigval1 = const_cast(&parent_ret); int sigval2 = start; int sigval3 = end; miqt_exec_callback_QListView_RowsAboutToBeRemoved(this, handle__RowsAboutToBeRemoved, sigval1, sigval2, sigval3); } // Wrapper to allow calling protected method void virtualbase_RowsAboutToBeRemoved(QModelIndex* parent, int start, int end) { QListView::rowsAboutToBeRemoved(*parent, static_cast(start), static_cast(end)); } // cgo.Handle value for overwritten implementation intptr_t handle__MouseMoveEvent = 0; // Subclass to allow providing a Go implementation virtual void mouseMoveEvent(QMouseEvent* e) override { if (handle__MouseMoveEvent == 0) { QListView::mouseMoveEvent(e); return; } QMouseEvent* sigval1 = e; miqt_exec_callback_QListView_MouseMoveEvent(this, handle__MouseMoveEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_MouseMoveEvent(QMouseEvent* e) { QListView::mouseMoveEvent(e); } // cgo.Handle value for overwritten implementation intptr_t handle__MouseReleaseEvent = 0; // Subclass to allow providing a Go implementation virtual void mouseReleaseEvent(QMouseEvent* e) override { if (handle__MouseReleaseEvent == 0) { QListView::mouseReleaseEvent(e); return; } QMouseEvent* sigval1 = e; miqt_exec_callback_QListView_MouseReleaseEvent(this, handle__MouseReleaseEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_MouseReleaseEvent(QMouseEvent* e) { QListView::mouseReleaseEvent(e); } // cgo.Handle value for overwritten implementation intptr_t handle__WheelEvent = 0; // Subclass to allow providing a Go implementation virtual void wheelEvent(QWheelEvent* e) override { if (handle__WheelEvent == 0) { QListView::wheelEvent(e); return; } QWheelEvent* sigval1 = e; miqt_exec_callback_QListView_WheelEvent(this, handle__WheelEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_WheelEvent(QWheelEvent* e) { QListView::wheelEvent(e); } // cgo.Handle value for overwritten implementation intptr_t handle__TimerEvent = 0; // Subclass to allow providing a Go implementation virtual void timerEvent(QTimerEvent* e) override { if (handle__TimerEvent == 0) { QListView::timerEvent(e); return; } QTimerEvent* sigval1 = e; miqt_exec_callback_QListView_TimerEvent(this, handle__TimerEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_TimerEvent(QTimerEvent* e) { QListView::timerEvent(e); } // cgo.Handle value for overwritten implementation intptr_t handle__ResizeEvent = 0; // Subclass to allow providing a Go implementation virtual void resizeEvent(QResizeEvent* e) override { if (handle__ResizeEvent == 0) { QListView::resizeEvent(e); return; } QResizeEvent* sigval1 = e; miqt_exec_callback_QListView_ResizeEvent(this, handle__ResizeEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_ResizeEvent(QResizeEvent* e) { QListView::resizeEvent(e); } // cgo.Handle value for overwritten implementation intptr_t handle__DragMoveEvent = 0; // Subclass to allow providing a Go implementation virtual void dragMoveEvent(QDragMoveEvent* e) override { if (handle__DragMoveEvent == 0) { QListView::dragMoveEvent(e); return; } QDragMoveEvent* sigval1 = e; miqt_exec_callback_QListView_DragMoveEvent(this, handle__DragMoveEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_DragMoveEvent(QDragMoveEvent* e) { QListView::dragMoveEvent(e); } // cgo.Handle value for overwritten implementation intptr_t handle__DragLeaveEvent = 0; // Subclass to allow providing a Go implementation virtual void dragLeaveEvent(QDragLeaveEvent* e) override { if (handle__DragLeaveEvent == 0) { QListView::dragLeaveEvent(e); return; } QDragLeaveEvent* sigval1 = e; miqt_exec_callback_QListView_DragLeaveEvent(this, handle__DragLeaveEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_DragLeaveEvent(QDragLeaveEvent* e) { QListView::dragLeaveEvent(e); } // cgo.Handle value for overwritten implementation intptr_t handle__DropEvent = 0; // Subclass to allow providing a Go implementation virtual void dropEvent(QDropEvent* e) override { if (handle__DropEvent == 0) { QListView::dropEvent(e); return; } QDropEvent* sigval1 = e; miqt_exec_callback_QListView_DropEvent(this, handle__DropEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_DropEvent(QDropEvent* e) { QListView::dropEvent(e); } // cgo.Handle value for overwritten implementation intptr_t handle__StartDrag = 0; // Subclass to allow providing a Go implementation virtual void startDrag(Qt::DropActions supportedActions) override { if (handle__StartDrag == 0) { QListView::startDrag(supportedActions); return; } Qt::DropActions supportedActions_ret = supportedActions; int sigval1 = static_cast(supportedActions_ret); miqt_exec_callback_QListView_StartDrag(this, handle__StartDrag, sigval1); } // Wrapper to allow calling protected method void virtualbase_StartDrag(int supportedActions) { QListView::startDrag(static_cast(supportedActions)); } // cgo.Handle value for overwritten implementation intptr_t handle__ViewOptions = 0; // Subclass to allow providing a Go implementation virtual QStyleOptionViewItem viewOptions() const override { if (handle__ViewOptions == 0) { return QListView::viewOptions(); } QStyleOptionViewItem* callback_return_value = miqt_exec_callback_QListView_ViewOptions(const_cast(this), handle__ViewOptions); return *callback_return_value; } // Wrapper to allow calling protected method QStyleOptionViewItem* virtualbase_ViewOptions() const { return new QStyleOptionViewItem(QListView::viewOptions()); } // cgo.Handle value for overwritten implementation intptr_t handle__PaintEvent = 0; // Subclass to allow providing a Go implementation virtual void paintEvent(QPaintEvent* e) override { if (handle__PaintEvent == 0) { QListView::paintEvent(e); return; } QPaintEvent* sigval1 = e; miqt_exec_callback_QListView_PaintEvent(this, handle__PaintEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_PaintEvent(QPaintEvent* e) { QListView::paintEvent(e); } // cgo.Handle value for overwritten implementation intptr_t handle__HorizontalOffset = 0; // Subclass to allow providing a Go implementation virtual int horizontalOffset() const override { if (handle__HorizontalOffset == 0) { return QListView::horizontalOffset(); } int callback_return_value = miqt_exec_callback_QListView_HorizontalOffset(const_cast(this), handle__HorizontalOffset); return static_cast(callback_return_value); } // Wrapper to allow calling protected method int virtualbase_HorizontalOffset() const { return QListView::horizontalOffset(); } // cgo.Handle value for overwritten implementation intptr_t handle__VerticalOffset = 0; // Subclass to allow providing a Go implementation virtual int verticalOffset() const override { if (handle__VerticalOffset == 0) { return QListView::verticalOffset(); } int callback_return_value = miqt_exec_callback_QListView_VerticalOffset(const_cast(this), handle__VerticalOffset); return static_cast(callback_return_value); } // Wrapper to allow calling protected method int virtualbase_VerticalOffset() const { return QListView::verticalOffset(); } // cgo.Handle value for overwritten implementation intptr_t handle__MoveCursor = 0; // Subclass to allow providing a Go implementation virtual QModelIndex moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers) override { if (handle__MoveCursor == 0) { return QListView::moveCursor(cursorAction, modifiers); } QAbstractItemView::CursorAction cursorAction_ret = cursorAction; int sigval1 = static_cast(cursorAction_ret); Qt::KeyboardModifiers modifiers_ret = modifiers; int sigval2 = static_cast(modifiers_ret); QModelIndex* callback_return_value = miqt_exec_callback_QListView_MoveCursor(this, handle__MoveCursor, sigval1, sigval2); return *callback_return_value; } // Wrapper to allow calling protected method QModelIndex* virtualbase_MoveCursor(int cursorAction, int modifiers) { return new QModelIndex(QListView::moveCursor(static_cast(cursorAction), static_cast(modifiers))); } // cgo.Handle value for overwritten implementation intptr_t handle__SetSelection = 0; // Subclass to allow providing a Go implementation virtual void setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags command) override { if (handle__SetSelection == 0) { QListView::setSelection(rect, command); return; } const QRect& rect_ret = rect; // Cast returned reference into pointer QRect* sigval1 = const_cast(&rect_ret); QItemSelectionModel::SelectionFlags command_ret = command; int sigval2 = static_cast(command_ret); miqt_exec_callback_QListView_SetSelection(this, handle__SetSelection, sigval1, sigval2); } // Wrapper to allow calling protected method void virtualbase_SetSelection(QRect* rect, int command) { QListView::setSelection(*rect, static_cast(command)); } // cgo.Handle value for overwritten implementation intptr_t handle__VisualRegionForSelection = 0; // Subclass to allow providing a Go implementation virtual QRegion visualRegionForSelection(const QItemSelection& selection) const override { if (handle__VisualRegionForSelection == 0) { return QListView::visualRegionForSelection(selection); } const QItemSelection& selection_ret = selection; // Cast returned reference into pointer QItemSelection* sigval1 = const_cast(&selection_ret); QRegion* callback_return_value = miqt_exec_callback_QListView_VisualRegionForSelection(const_cast(this), handle__VisualRegionForSelection, sigval1); return *callback_return_value; } // Wrapper to allow calling protected method QRegion* virtualbase_VisualRegionForSelection(QItemSelection* selection) const { return new QRegion(QListView::visualRegionForSelection(*selection)); } // cgo.Handle value for overwritten implementation intptr_t handle__SelectedIndexes = 0; // Subclass to allow providing a Go implementation virtual QModelIndexList selectedIndexes() const override { if (handle__SelectedIndexes == 0) { return QListView::selectedIndexes(); } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QListView_SelectedIndexes(const_cast(this), handle__SelectedIndexes); QModelIndexList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { callback_return_value_QList.push_back(*(callback_return_value_arr[i])); } return callback_return_value_QList; } // Wrapper to allow calling protected method struct miqt_array /* of QModelIndex* */ virtualbase_SelectedIndexes() const { QModelIndexList _ret = QListView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); for (size_t i = 0, e = _ret.length(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; _out.len = _ret.length(); _out.data = static_cast(_arr); return _out; } // cgo.Handle value for overwritten implementation intptr_t handle__UpdateGeometries = 0; // Subclass to allow providing a Go implementation virtual void updateGeometries() override { if (handle__UpdateGeometries == 0) { QListView::updateGeometries(); return; } miqt_exec_callback_QListView_UpdateGeometries(this, handle__UpdateGeometries); } // Wrapper to allow calling protected method void virtualbase_UpdateGeometries() { QListView::updateGeometries(); } // cgo.Handle value for overwritten implementation intptr_t handle__IsIndexHidden = 0; // Subclass to allow providing a Go implementation virtual bool isIndexHidden(const QModelIndex& index) const override { if (handle__IsIndexHidden == 0) { return QListView::isIndexHidden(index); } const QModelIndex& index_ret = index; // Cast returned reference into pointer QModelIndex* sigval1 = const_cast(&index_ret); bool callback_return_value = miqt_exec_callback_QListView_IsIndexHidden(const_cast(this), handle__IsIndexHidden, sigval1); return callback_return_value; } // Wrapper to allow calling protected method bool virtualbase_IsIndexHidden(QModelIndex* index) const { return QListView::isIndexHidden(*index); } // cgo.Handle value for overwritten implementation intptr_t handle__SelectionChanged = 0; // Subclass to allow providing a Go implementation virtual void selectionChanged(const QItemSelection& selected, const QItemSelection& deselected) override { if (handle__SelectionChanged == 0) { QListView::selectionChanged(selected, deselected); return; } const QItemSelection& selected_ret = selected; // Cast returned reference into pointer QItemSelection* sigval1 = const_cast(&selected_ret); const QItemSelection& deselected_ret = deselected; // Cast returned reference into pointer QItemSelection* sigval2 = const_cast(&deselected_ret); miqt_exec_callback_QListView_SelectionChanged(this, handle__SelectionChanged, sigval1, sigval2); } // Wrapper to allow calling protected method void virtualbase_SelectionChanged(QItemSelection* selected, QItemSelection* deselected) { QListView::selectionChanged(*selected, *deselected); } // cgo.Handle value for overwritten implementation intptr_t handle__CurrentChanged = 0; // Subclass to allow providing a Go implementation virtual void currentChanged(const QModelIndex& current, const QModelIndex& previous) override { if (handle__CurrentChanged == 0) { QListView::currentChanged(current, previous); return; } const QModelIndex& current_ret = current; // Cast returned reference into pointer QModelIndex* sigval1 = const_cast(¤t_ret); const QModelIndex& previous_ret = previous; // Cast returned reference into pointer QModelIndex* sigval2 = const_cast(&previous_ret); miqt_exec_callback_QListView_CurrentChanged(this, handle__CurrentChanged, sigval1, sigval2); } // Wrapper to allow calling protected method void virtualbase_CurrentChanged(QModelIndex* current, QModelIndex* previous) { QListView::currentChanged(*current, *previous); } // cgo.Handle value for overwritten implementation intptr_t handle__ViewportSizeHint = 0; // Subclass to allow providing a Go implementation virtual QSize viewportSizeHint() const override { if (handle__ViewportSizeHint == 0) { return QListView::viewportSizeHint(); } QSize* callback_return_value = miqt_exec_callback_QListView_ViewportSizeHint(const_cast(this), handle__ViewportSizeHint); return *callback_return_value; } // Wrapper to allow calling protected method QSize* virtualbase_ViewportSizeHint() const { return new QSize(QListView::viewportSizeHint()); } // cgo.Handle value for overwritten implementation intptr_t handle__SetModel = 0; // Subclass to allow providing a Go implementation virtual void setModel(QAbstractItemModel* model) override { if (handle__SetModel == 0) { QListView::setModel(model); return; } QAbstractItemModel* sigval1 = model; miqt_exec_callback_QListView_SetModel(this, handle__SetModel, sigval1); } // Wrapper to allow calling protected method void virtualbase_SetModel(QAbstractItemModel* model) { QListView::setModel(model); } // cgo.Handle value for overwritten implementation intptr_t handle__SetSelectionModel = 0; // Subclass to allow providing a Go implementation virtual void setSelectionModel(QItemSelectionModel* selectionModel) override { if (handle__SetSelectionModel == 0) { QListView::setSelectionModel(selectionModel); return; } QItemSelectionModel* sigval1 = selectionModel; miqt_exec_callback_QListView_SetSelectionModel(this, handle__SetSelectionModel, sigval1); } // Wrapper to allow calling protected method void virtualbase_SetSelectionModel(QItemSelectionModel* selectionModel) { QListView::setSelectionModel(selectionModel); } // cgo.Handle value for overwritten implementation intptr_t handle__KeyboardSearch = 0; // Subclass to allow providing a Go implementation virtual void keyboardSearch(const QString& search) override { if (handle__KeyboardSearch == 0) { QListView::keyboardSearch(search); return; } const QString search_ret = search; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray search_b = search_ret.toUtf8(); struct miqt_string search_ms; search_ms.len = search_b.length(); search_ms.data = static_cast(malloc(search_ms.len)); memcpy(search_ms.data, search_b.data(), search_ms.len); struct miqt_string sigval1 = search_ms; miqt_exec_callback_QListView_KeyboardSearch(this, handle__KeyboardSearch, sigval1); } // Wrapper to allow calling protected method void virtualbase_KeyboardSearch(struct miqt_string search) { QString search_QString = QString::fromUtf8(search.data, search.len); QListView::keyboardSearch(search_QString); } // cgo.Handle value for overwritten implementation intptr_t handle__SizeHintForRow = 0; // Subclass to allow providing a Go implementation virtual int sizeHintForRow(int row) const override { if (handle__SizeHintForRow == 0) { return QListView::sizeHintForRow(row); } int sigval1 = row; int callback_return_value = miqt_exec_callback_QListView_SizeHintForRow(const_cast(this), handle__SizeHintForRow, sigval1); return static_cast(callback_return_value); } // Wrapper to allow calling protected method int virtualbase_SizeHintForRow(int row) const { return QListView::sizeHintForRow(static_cast(row)); } // cgo.Handle value for overwritten implementation intptr_t handle__SizeHintForColumn = 0; // Subclass to allow providing a Go implementation virtual int sizeHintForColumn(int column) const override { if (handle__SizeHintForColumn == 0) { return QListView::sizeHintForColumn(column); } int sigval1 = column; int callback_return_value = miqt_exec_callback_QListView_SizeHintForColumn(const_cast(this), handle__SizeHintForColumn, sigval1); return static_cast(callback_return_value); } // Wrapper to allow calling protected method int virtualbase_SizeHintForColumn(int column) const { return QListView::sizeHintForColumn(static_cast(column)); } // cgo.Handle value for overwritten implementation intptr_t handle__InputMethodQuery = 0; // Subclass to allow providing a Go implementation virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const override { if (handle__InputMethodQuery == 0) { return QListView::inputMethodQuery(query); } Qt::InputMethodQuery query_ret = query; int sigval1 = static_cast(query_ret); QVariant* callback_return_value = miqt_exec_callback_QListView_InputMethodQuery(const_cast(this), handle__InputMethodQuery, sigval1); return *callback_return_value; } // Wrapper to allow calling protected method QVariant* virtualbase_InputMethodQuery(int query) const { return new QVariant(QListView::inputMethodQuery(static_cast(query))); } // cgo.Handle value for overwritten implementation intptr_t handle__SelectAll = 0; // Subclass to allow providing a Go implementation virtual void selectAll() override { if (handle__SelectAll == 0) { QListView::selectAll(); return; } miqt_exec_callback_QListView_SelectAll(this, handle__SelectAll); } // Wrapper to allow calling protected method void virtualbase_SelectAll() { QListView::selectAll(); } // cgo.Handle value for overwritten implementation intptr_t handle__UpdateEditorData = 0; // Subclass to allow providing a Go implementation virtual void updateEditorData() override { if (handle__UpdateEditorData == 0) { QListView::updateEditorData(); return; } miqt_exec_callback_QListView_UpdateEditorData(this, handle__UpdateEditorData); } // Wrapper to allow calling protected method void virtualbase_UpdateEditorData() { QListView::updateEditorData(); } // cgo.Handle value for overwritten implementation intptr_t handle__UpdateEditorGeometries = 0; // Subclass to allow providing a Go implementation virtual void updateEditorGeometries() override { if (handle__UpdateEditorGeometries == 0) { QListView::updateEditorGeometries(); return; } miqt_exec_callback_QListView_UpdateEditorGeometries(this, handle__UpdateEditorGeometries); } // Wrapper to allow calling protected method void virtualbase_UpdateEditorGeometries() { QListView::updateEditorGeometries(); } // cgo.Handle value for overwritten implementation intptr_t handle__VerticalScrollbarAction = 0; // Subclass to allow providing a Go implementation virtual void verticalScrollbarAction(int action) override { if (handle__VerticalScrollbarAction == 0) { QListView::verticalScrollbarAction(action); return; } int sigval1 = action; miqt_exec_callback_QListView_VerticalScrollbarAction(this, handle__VerticalScrollbarAction, sigval1); } // Wrapper to allow calling protected method void virtualbase_VerticalScrollbarAction(int action) { QListView::verticalScrollbarAction(static_cast(action)); } // cgo.Handle value for overwritten implementation intptr_t handle__HorizontalScrollbarAction = 0; // Subclass to allow providing a Go implementation virtual void horizontalScrollbarAction(int action) override { if (handle__HorizontalScrollbarAction == 0) { QListView::horizontalScrollbarAction(action); return; } int sigval1 = action; miqt_exec_callback_QListView_HorizontalScrollbarAction(this, handle__HorizontalScrollbarAction, sigval1); } // Wrapper to allow calling protected method void virtualbase_HorizontalScrollbarAction(int action) { QListView::horizontalScrollbarAction(static_cast(action)); } // cgo.Handle value for overwritten implementation intptr_t handle__VerticalScrollbarValueChanged = 0; // Subclass to allow providing a Go implementation virtual void verticalScrollbarValueChanged(int value) override { if (handle__VerticalScrollbarValueChanged == 0) { QListView::verticalScrollbarValueChanged(value); return; } int sigval1 = value; miqt_exec_callback_QListView_VerticalScrollbarValueChanged(this, handle__VerticalScrollbarValueChanged, sigval1); } // Wrapper to allow calling protected method void virtualbase_VerticalScrollbarValueChanged(int value) { QListView::verticalScrollbarValueChanged(static_cast(value)); } // cgo.Handle value for overwritten implementation intptr_t handle__HorizontalScrollbarValueChanged = 0; // Subclass to allow providing a Go implementation virtual void horizontalScrollbarValueChanged(int value) override { if (handle__HorizontalScrollbarValueChanged == 0) { QListView::horizontalScrollbarValueChanged(value); return; } int sigval1 = value; miqt_exec_callback_QListView_HorizontalScrollbarValueChanged(this, handle__HorizontalScrollbarValueChanged, sigval1); } // Wrapper to allow calling protected method void virtualbase_HorizontalScrollbarValueChanged(int value) { QListView::horizontalScrollbarValueChanged(static_cast(value)); } // cgo.Handle value for overwritten implementation intptr_t handle__CloseEditor = 0; // Subclass to allow providing a Go implementation virtual void closeEditor(QWidget* editor, QAbstractItemDelegate::EndEditHint hint) override { if (handle__CloseEditor == 0) { QListView::closeEditor(editor, hint); return; } QWidget* sigval1 = editor; QAbstractItemDelegate::EndEditHint hint_ret = hint; int sigval2 = static_cast(hint_ret); miqt_exec_callback_QListView_CloseEditor(this, handle__CloseEditor, sigval1, sigval2); } // Wrapper to allow calling protected method void virtualbase_CloseEditor(QWidget* editor, int hint) { QListView::closeEditor(editor, static_cast(hint)); } // cgo.Handle value for overwritten implementation intptr_t handle__CommitData = 0; // Subclass to allow providing a Go implementation virtual void commitData(QWidget* editor) override { if (handle__CommitData == 0) { QListView::commitData(editor); return; } QWidget* sigval1 = editor; miqt_exec_callback_QListView_CommitData(this, handle__CommitData, sigval1); } // Wrapper to allow calling protected method void virtualbase_CommitData(QWidget* editor) { QListView::commitData(editor); } // cgo.Handle value for overwritten implementation intptr_t handle__EditorDestroyed = 0; // Subclass to allow providing a Go implementation virtual void editorDestroyed(QObject* editor) override { if (handle__EditorDestroyed == 0) { QListView::editorDestroyed(editor); return; } QObject* sigval1 = editor; miqt_exec_callback_QListView_EditorDestroyed(this, handle__EditorDestroyed, sigval1); } // Wrapper to allow calling protected method void virtualbase_EditorDestroyed(QObject* editor) { QListView::editorDestroyed(editor); } // cgo.Handle value for overwritten implementation intptr_t handle__Edit2 = 0; // Subclass to allow providing a Go implementation virtual bool edit(const QModelIndex& index, QAbstractItemView::EditTrigger trigger, QEvent* event) override { if (handle__Edit2 == 0) { return QListView::edit(index, trigger, event); } const QModelIndex& index_ret = index; // Cast returned reference into pointer QModelIndex* sigval1 = const_cast(&index_ret); QAbstractItemView::EditTrigger trigger_ret = trigger; int sigval2 = static_cast(trigger_ret); QEvent* sigval3 = event; bool callback_return_value = miqt_exec_callback_QListView_Edit2(this, handle__Edit2, sigval1, sigval2, sigval3); return callback_return_value; } // Wrapper to allow calling protected method bool virtualbase_Edit2(QModelIndex* index, int trigger, QEvent* event) { return QListView::edit(*index, static_cast(trigger), event); } // cgo.Handle value for overwritten implementation intptr_t handle__SelectionCommand = 0; // Subclass to allow providing a Go implementation virtual QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex& index, const QEvent* event) const override { if (handle__SelectionCommand == 0) { return QListView::selectionCommand(index, event); } const QModelIndex& index_ret = index; // Cast returned reference into pointer QModelIndex* sigval1 = const_cast(&index_ret); QEvent* sigval2 = (QEvent*) event; int callback_return_value = miqt_exec_callback_QListView_SelectionCommand(const_cast(this), handle__SelectionCommand, sigval1, sigval2); return static_cast(callback_return_value); } // Wrapper to allow calling protected method int virtualbase_SelectionCommand(QModelIndex* index, QEvent* event) const { QItemSelectionModel::SelectionFlags _ret = QListView::selectionCommand(*index, event); return static_cast(_ret); } // cgo.Handle value for overwritten implementation intptr_t handle__FocusNextPrevChild = 0; // Subclass to allow providing a Go implementation virtual bool focusNextPrevChild(bool next) override { if (handle__FocusNextPrevChild == 0) { return QListView::focusNextPrevChild(next); } bool sigval1 = next; bool callback_return_value = miqt_exec_callback_QListView_FocusNextPrevChild(this, handle__FocusNextPrevChild, sigval1); return callback_return_value; } // Wrapper to allow calling protected method bool virtualbase_FocusNextPrevChild(bool next) { return QListView::focusNextPrevChild(next); } // cgo.Handle value for overwritten implementation intptr_t handle__ViewportEvent = 0; // Subclass to allow providing a Go implementation virtual bool viewportEvent(QEvent* event) override { if (handle__ViewportEvent == 0) { return QListView::viewportEvent(event); } QEvent* sigval1 = event; bool callback_return_value = miqt_exec_callback_QListView_ViewportEvent(this, handle__ViewportEvent, sigval1); return callback_return_value; } // Wrapper to allow calling protected method bool virtualbase_ViewportEvent(QEvent* event) { return QListView::viewportEvent(event); } // cgo.Handle value for overwritten implementation intptr_t handle__MousePressEvent = 0; // Subclass to allow providing a Go implementation virtual void mousePressEvent(QMouseEvent* event) override { if (handle__MousePressEvent == 0) { QListView::mousePressEvent(event); return; } QMouseEvent* sigval1 = event; miqt_exec_callback_QListView_MousePressEvent(this, handle__MousePressEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_MousePressEvent(QMouseEvent* event) { QListView::mousePressEvent(event); } // cgo.Handle value for overwritten implementation intptr_t handle__MouseDoubleClickEvent = 0; // Subclass to allow providing a Go implementation virtual void mouseDoubleClickEvent(QMouseEvent* event) override { if (handle__MouseDoubleClickEvent == 0) { QListView::mouseDoubleClickEvent(event); return; } QMouseEvent* sigval1 = event; miqt_exec_callback_QListView_MouseDoubleClickEvent(this, handle__MouseDoubleClickEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_MouseDoubleClickEvent(QMouseEvent* event) { QListView::mouseDoubleClickEvent(event); } // cgo.Handle value for overwritten implementation intptr_t handle__DragEnterEvent = 0; // Subclass to allow providing a Go implementation virtual void dragEnterEvent(QDragEnterEvent* event) override { if (handle__DragEnterEvent == 0) { QListView::dragEnterEvent(event); return; } QDragEnterEvent* sigval1 = event; miqt_exec_callback_QListView_DragEnterEvent(this, handle__DragEnterEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_DragEnterEvent(QDragEnterEvent* event) { QListView::dragEnterEvent(event); } // cgo.Handle value for overwritten implementation intptr_t handle__FocusInEvent = 0; // Subclass to allow providing a Go implementation virtual void focusInEvent(QFocusEvent* event) override { if (handle__FocusInEvent == 0) { QListView::focusInEvent(event); return; } QFocusEvent* sigval1 = event; miqt_exec_callback_QListView_FocusInEvent(this, handle__FocusInEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_FocusInEvent(QFocusEvent* event) { QListView::focusInEvent(event); } // cgo.Handle value for overwritten implementation intptr_t handle__FocusOutEvent = 0; // Subclass to allow providing a Go implementation virtual void focusOutEvent(QFocusEvent* event) override { if (handle__FocusOutEvent == 0) { QListView::focusOutEvent(event); return; } QFocusEvent* sigval1 = event; miqt_exec_callback_QListView_FocusOutEvent(this, handle__FocusOutEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_FocusOutEvent(QFocusEvent* event) { QListView::focusOutEvent(event); } // cgo.Handle value for overwritten implementation intptr_t handle__KeyPressEvent = 0; // Subclass to allow providing a Go implementation virtual void keyPressEvent(QKeyEvent* event) override { if (handle__KeyPressEvent == 0) { QListView::keyPressEvent(event); return; } QKeyEvent* sigval1 = event; miqt_exec_callback_QListView_KeyPressEvent(this, handle__KeyPressEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_KeyPressEvent(QKeyEvent* event) { QListView::keyPressEvent(event); } // cgo.Handle value for overwritten implementation intptr_t handle__InputMethodEvent = 0; // Subclass to allow providing a Go implementation virtual void inputMethodEvent(QInputMethodEvent* event) override { if (handle__InputMethodEvent == 0) { QListView::inputMethodEvent(event); return; } QInputMethodEvent* sigval1 = event; miqt_exec_callback_QListView_InputMethodEvent(this, handle__InputMethodEvent, sigval1); } // Wrapper to allow calling protected method void virtualbase_InputMethodEvent(QInputMethodEvent* event) { QListView::inputMethodEvent(event); } // cgo.Handle value for overwritten implementation intptr_t handle__EventFilter = 0; // Subclass to allow providing a Go implementation virtual bool eventFilter(QObject* object, QEvent* event) override { if (handle__EventFilter == 0) { return QListView::eventFilter(object, event); } QObject* sigval1 = object; QEvent* sigval2 = event; bool callback_return_value = miqt_exec_callback_QListView_EventFilter(this, handle__EventFilter, sigval1, sigval2); return callback_return_value; } // Wrapper to allow calling protected method bool virtualbase_EventFilter(QObject* object, QEvent* event) { return QListView::eventFilter(object, event); } }; QListView* QListView_new(QWidget* parent) { return new MiqtVirtualQListView(parent); } QListView* QListView_new2() { return new MiqtVirtualQListView(); } void QListView_virtbase(QListView* src, QAbstractItemView** outptr_QAbstractItemView) { *outptr_QAbstractItemView = static_cast(src); } QMetaObject* QListView_MetaObject(const QListView* self) { return (QMetaObject*) self->metaObject(); } void* QListView_Metacast(QListView* self, const char* param1) { return self->qt_metacast(param1); } struct miqt_string QListView_Tr(const char* s) { QString _ret = QListView::tr(s); // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray _b = _ret.toUtf8(); struct miqt_string _ms; _ms.len = _b.length(); _ms.data = static_cast(malloc(_ms.len)); memcpy(_ms.data, _b.data(), _ms.len); return _ms; } struct miqt_string QListView_TrUtf8(const char* s) { QString _ret = QListView::trUtf8(s); // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray _b = _ret.toUtf8(); struct miqt_string _ms; _ms.len = _b.length(); _ms.data = static_cast(malloc(_ms.len)); memcpy(_ms.data, _b.data(), _ms.len); return _ms; } void QListView_SetMovement(QListView* self, int movement) { self->setMovement(static_cast(movement)); } int QListView_Movement(const QListView* self) { QListView::Movement _ret = self->movement(); return static_cast(_ret); } void QListView_SetFlow(QListView* self, int flow) { self->setFlow(static_cast(flow)); } int QListView_Flow(const QListView* self) { QListView::Flow _ret = self->flow(); return static_cast(_ret); } void QListView_SetWrapping(QListView* self, bool enable) { self->setWrapping(enable); } bool QListView_IsWrapping(const QListView* self) { return self->isWrapping(); } void QListView_SetResizeMode(QListView* self, int mode) { self->setResizeMode(static_cast(mode)); } int QListView_ResizeMode(const QListView* self) { QListView::ResizeMode _ret = self->resizeMode(); return static_cast(_ret); } void QListView_SetLayoutMode(QListView* self, int mode) { self->setLayoutMode(static_cast(mode)); } int QListView_LayoutMode(const QListView* self) { QListView::LayoutMode _ret = self->layoutMode(); return static_cast(_ret); } void QListView_SetSpacing(QListView* self, int space) { self->setSpacing(static_cast(space)); } int QListView_Spacing(const QListView* self) { return self->spacing(); } void QListView_SetBatchSize(QListView* self, int batchSize) { self->setBatchSize(static_cast(batchSize)); } int QListView_BatchSize(const QListView* self) { return self->batchSize(); } void QListView_SetGridSize(QListView* self, QSize* size) { self->setGridSize(*size); } QSize* QListView_GridSize(const QListView* self) { return new QSize(self->gridSize()); } void QListView_SetViewMode(QListView* self, int mode) { self->setViewMode(static_cast(mode)); } int QListView_ViewMode(const QListView* self) { QListView::ViewMode _ret = self->viewMode(); return static_cast(_ret); } void QListView_ClearPropertyFlags(QListView* self) { self->clearPropertyFlags(); } bool QListView_IsRowHidden(const QListView* self, int row) { return self->isRowHidden(static_cast(row)); } void QListView_SetRowHidden(QListView* self, int row, bool hide) { self->setRowHidden(static_cast(row), hide); } void QListView_SetModelColumn(QListView* self, int column) { self->setModelColumn(static_cast(column)); } int QListView_ModelColumn(const QListView* self) { return self->modelColumn(); } void QListView_SetUniformItemSizes(QListView* self, bool enable) { self->setUniformItemSizes(enable); } bool QListView_UniformItemSizes(const QListView* self) { return self->uniformItemSizes(); } void QListView_SetWordWrap(QListView* self, bool on) { self->setWordWrap(on); } bool QListView_WordWrap(const QListView* self) { return self->wordWrap(); } void QListView_SetSelectionRectVisible(QListView* self, bool show) { self->setSelectionRectVisible(show); } bool QListView_IsSelectionRectVisible(const QListView* self) { return self->isSelectionRectVisible(); } void QListView_SetItemAlignment(QListView* self, int alignment) { self->setItemAlignment(static_cast(alignment)); } int QListView_ItemAlignment(const QListView* self) { Qt::Alignment _ret = self->itemAlignment(); return static_cast(_ret); } QRect* QListView_VisualRect(const QListView* self, QModelIndex* index) { return new QRect(self->visualRect(*index)); } void QListView_ScrollTo(QListView* self, QModelIndex* index, int hint) { self->scrollTo(*index, static_cast(hint)); } QModelIndex* QListView_IndexAt(const QListView* self, QPoint* p) { return new QModelIndex(self->indexAt(*p)); } void QListView_DoItemsLayout(QListView* self) { self->doItemsLayout(); } void QListView_Reset(QListView* self) { self->reset(); } void QListView_SetRootIndex(QListView* self, QModelIndex* index) { self->setRootIndex(*index); } void QListView_IndexesMoved(QListView* self, struct miqt_array /* of QModelIndex* */ indexes) { QModelIndexList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { indexes_QList.push_back(*(indexes_arr[i])); } self->indexesMoved(indexes_QList); } void QListView_connect_IndexesMoved(QListView* self, intptr_t slot) { MiqtVirtualQListView::connect(self, static_cast(&QListView::indexesMoved), self, [=](const QModelIndexList& indexes) { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; indexes_out.len = indexes_ret.length(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; miqt_exec_callback_QListView_IndexesMoved(slot, sigval1); }); } struct miqt_string QListView_Tr2(const char* s, const char* c) { QString _ret = QListView::tr(s, c); // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray _b = _ret.toUtf8(); struct miqt_string _ms; _ms.len = _b.length(); _ms.data = static_cast(malloc(_ms.len)); memcpy(_ms.data, _b.data(), _ms.len); return _ms; } struct miqt_string QListView_Tr3(const char* s, const char* c, int n) { QString _ret = QListView::tr(s, c, static_cast(n)); // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray _b = _ret.toUtf8(); struct miqt_string _ms; _ms.len = _b.length(); _ms.data = static_cast(malloc(_ms.len)); memcpy(_ms.data, _b.data(), _ms.len); return _ms; } struct miqt_string QListView_TrUtf82(const char* s, const char* c) { QString _ret = QListView::trUtf8(s, c); // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray _b = _ret.toUtf8(); struct miqt_string _ms; _ms.len = _b.length(); _ms.data = static_cast(malloc(_ms.len)); memcpy(_ms.data, _b.data(), _ms.len); return _ms; } struct miqt_string QListView_TrUtf83(const char* s, const char* c, int n) { QString _ret = QListView::trUtf8(s, c, static_cast(n)); // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray _b = _ret.toUtf8(); struct miqt_string _ms; _ms.len = _b.length(); _ms.data = static_cast(malloc(_ms.len)); memcpy(_ms.data, _b.data(), _ms.len); return _ms; } void QListView_override_virtual_VisualRect(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__VisualRect = slot; } QRect* QListView_virtualbase_VisualRect(const void* self, QModelIndex* index) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_VisualRect(index); } void QListView_override_virtual_ScrollTo(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__ScrollTo = slot; } void QListView_virtualbase_ScrollTo(void* self, QModelIndex* index, int hint) { ( (MiqtVirtualQListView*)(self) )->virtualbase_ScrollTo(index, hint); } void QListView_override_virtual_IndexAt(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__IndexAt = slot; } QModelIndex* QListView_virtualbase_IndexAt(const void* self, QPoint* p) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_IndexAt(p); } void QListView_override_virtual_DoItemsLayout(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__DoItemsLayout = slot; } void QListView_virtualbase_DoItemsLayout(void* self) { ( (MiqtVirtualQListView*)(self) )->virtualbase_DoItemsLayout(); } void QListView_override_virtual_Reset(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__Reset = slot; } void QListView_virtualbase_Reset(void* self) { ( (MiqtVirtualQListView*)(self) )->virtualbase_Reset(); } void QListView_override_virtual_SetRootIndex(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__SetRootIndex = slot; } void QListView_virtualbase_SetRootIndex(void* self, QModelIndex* index) { ( (MiqtVirtualQListView*)(self) )->virtualbase_SetRootIndex(index); } void QListView_override_virtual_Event(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__Event = slot; } bool QListView_virtualbase_Event(void* self, QEvent* e) { return ( (MiqtVirtualQListView*)(self) )->virtualbase_Event(e); } void QListView_override_virtual_ScrollContentsBy(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__ScrollContentsBy = slot; } void QListView_virtualbase_ScrollContentsBy(void* self, int dx, int dy) { ( (MiqtVirtualQListView*)(self) )->virtualbase_ScrollContentsBy(dx, dy); } void QListView_override_virtual_DataChanged(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__DataChanged = slot; } void QListView_virtualbase_DataChanged(void* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { ( (MiqtVirtualQListView*)(self) )->virtualbase_DataChanged(topLeft, bottomRight, roles); } void QListView_override_virtual_RowsInserted(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__RowsInserted = slot; } void QListView_virtualbase_RowsInserted(void* self, QModelIndex* parent, int start, int end) { ( (MiqtVirtualQListView*)(self) )->virtualbase_RowsInserted(parent, start, end); } void QListView_override_virtual_RowsAboutToBeRemoved(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__RowsAboutToBeRemoved = slot; } void QListView_virtualbase_RowsAboutToBeRemoved(void* self, QModelIndex* parent, int start, int end) { ( (MiqtVirtualQListView*)(self) )->virtualbase_RowsAboutToBeRemoved(parent, start, end); } void QListView_override_virtual_MouseMoveEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__MouseMoveEvent = slot; } void QListView_virtualbase_MouseMoveEvent(void* self, QMouseEvent* e) { ( (MiqtVirtualQListView*)(self) )->virtualbase_MouseMoveEvent(e); } void QListView_override_virtual_MouseReleaseEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__MouseReleaseEvent = slot; } void QListView_virtualbase_MouseReleaseEvent(void* self, QMouseEvent* e) { ( (MiqtVirtualQListView*)(self) )->virtualbase_MouseReleaseEvent(e); } void QListView_override_virtual_WheelEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__WheelEvent = slot; } void QListView_virtualbase_WheelEvent(void* self, QWheelEvent* e) { ( (MiqtVirtualQListView*)(self) )->virtualbase_WheelEvent(e); } void QListView_override_virtual_TimerEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__TimerEvent = slot; } void QListView_virtualbase_TimerEvent(void* self, QTimerEvent* e) { ( (MiqtVirtualQListView*)(self) )->virtualbase_TimerEvent(e); } void QListView_override_virtual_ResizeEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__ResizeEvent = slot; } void QListView_virtualbase_ResizeEvent(void* self, QResizeEvent* e) { ( (MiqtVirtualQListView*)(self) )->virtualbase_ResizeEvent(e); } void QListView_override_virtual_DragMoveEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__DragMoveEvent = slot; } void QListView_virtualbase_DragMoveEvent(void* self, QDragMoveEvent* e) { ( (MiqtVirtualQListView*)(self) )->virtualbase_DragMoveEvent(e); } void QListView_override_virtual_DragLeaveEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__DragLeaveEvent = slot; } void QListView_virtualbase_DragLeaveEvent(void* self, QDragLeaveEvent* e) { ( (MiqtVirtualQListView*)(self) )->virtualbase_DragLeaveEvent(e); } void QListView_override_virtual_DropEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__DropEvent = slot; } void QListView_virtualbase_DropEvent(void* self, QDropEvent* e) { ( (MiqtVirtualQListView*)(self) )->virtualbase_DropEvent(e); } void QListView_override_virtual_StartDrag(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__StartDrag = slot; } void QListView_virtualbase_StartDrag(void* self, int supportedActions) { ( (MiqtVirtualQListView*)(self) )->virtualbase_StartDrag(supportedActions); } void QListView_override_virtual_ViewOptions(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__ViewOptions = slot; } QStyleOptionViewItem* QListView_virtualbase_ViewOptions(const void* self) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_ViewOptions(); } void QListView_override_virtual_PaintEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__PaintEvent = slot; } void QListView_virtualbase_PaintEvent(void* self, QPaintEvent* e) { ( (MiqtVirtualQListView*)(self) )->virtualbase_PaintEvent(e); } void QListView_override_virtual_HorizontalOffset(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__HorizontalOffset = slot; } int QListView_virtualbase_HorizontalOffset(const void* self) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_HorizontalOffset(); } void QListView_override_virtual_VerticalOffset(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__VerticalOffset = slot; } int QListView_virtualbase_VerticalOffset(const void* self) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_VerticalOffset(); } void QListView_override_virtual_MoveCursor(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__MoveCursor = slot; } QModelIndex* QListView_virtualbase_MoveCursor(void* self, int cursorAction, int modifiers) { return ( (MiqtVirtualQListView*)(self) )->virtualbase_MoveCursor(cursorAction, modifiers); } void QListView_override_virtual_SetSelection(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__SetSelection = slot; } void QListView_virtualbase_SetSelection(void* self, QRect* rect, int command) { ( (MiqtVirtualQListView*)(self) )->virtualbase_SetSelection(rect, command); } void QListView_override_virtual_VisualRegionForSelection(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__VisualRegionForSelection = slot; } QRegion* QListView_virtualbase_VisualRegionForSelection(const void* self, QItemSelection* selection) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_VisualRegionForSelection(selection); } void QListView_override_virtual_SelectedIndexes(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__SelectedIndexes = slot; } struct miqt_array /* of QModelIndex* */ QListView_virtualbase_SelectedIndexes(const void* self) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_SelectedIndexes(); } void QListView_override_virtual_UpdateGeometries(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__UpdateGeometries = slot; } void QListView_virtualbase_UpdateGeometries(void* self) { ( (MiqtVirtualQListView*)(self) )->virtualbase_UpdateGeometries(); } void QListView_override_virtual_IsIndexHidden(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__IsIndexHidden = slot; } bool QListView_virtualbase_IsIndexHidden(const void* self, QModelIndex* index) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_IsIndexHidden(index); } void QListView_override_virtual_SelectionChanged(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__SelectionChanged = slot; } void QListView_virtualbase_SelectionChanged(void* self, QItemSelection* selected, QItemSelection* deselected) { ( (MiqtVirtualQListView*)(self) )->virtualbase_SelectionChanged(selected, deselected); } void QListView_override_virtual_CurrentChanged(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__CurrentChanged = slot; } void QListView_virtualbase_CurrentChanged(void* self, QModelIndex* current, QModelIndex* previous) { ( (MiqtVirtualQListView*)(self) )->virtualbase_CurrentChanged(current, previous); } void QListView_override_virtual_ViewportSizeHint(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__ViewportSizeHint = slot; } QSize* QListView_virtualbase_ViewportSizeHint(const void* self) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_ViewportSizeHint(); } void QListView_override_virtual_SetModel(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__SetModel = slot; } void QListView_virtualbase_SetModel(void* self, QAbstractItemModel* model) { ( (MiqtVirtualQListView*)(self) )->virtualbase_SetModel(model); } void QListView_override_virtual_SetSelectionModel(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__SetSelectionModel = slot; } void QListView_virtualbase_SetSelectionModel(void* self, QItemSelectionModel* selectionModel) { ( (MiqtVirtualQListView*)(self) )->virtualbase_SetSelectionModel(selectionModel); } void QListView_override_virtual_KeyboardSearch(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__KeyboardSearch = slot; } void QListView_virtualbase_KeyboardSearch(void* self, struct miqt_string search) { ( (MiqtVirtualQListView*)(self) )->virtualbase_KeyboardSearch(search); } void QListView_override_virtual_SizeHintForRow(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__SizeHintForRow = slot; } int QListView_virtualbase_SizeHintForRow(const void* self, int row) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_SizeHintForRow(row); } void QListView_override_virtual_SizeHintForColumn(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__SizeHintForColumn = slot; } int QListView_virtualbase_SizeHintForColumn(const void* self, int column) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_SizeHintForColumn(column); } void QListView_override_virtual_InputMethodQuery(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__InputMethodQuery = slot; } QVariant* QListView_virtualbase_InputMethodQuery(const void* self, int query) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_InputMethodQuery(query); } void QListView_override_virtual_SelectAll(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__SelectAll = slot; } void QListView_virtualbase_SelectAll(void* self) { ( (MiqtVirtualQListView*)(self) )->virtualbase_SelectAll(); } void QListView_override_virtual_UpdateEditorData(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__UpdateEditorData = slot; } void QListView_virtualbase_UpdateEditorData(void* self) { ( (MiqtVirtualQListView*)(self) )->virtualbase_UpdateEditorData(); } void QListView_override_virtual_UpdateEditorGeometries(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__UpdateEditorGeometries = slot; } void QListView_virtualbase_UpdateEditorGeometries(void* self) { ( (MiqtVirtualQListView*)(self) )->virtualbase_UpdateEditorGeometries(); } void QListView_override_virtual_VerticalScrollbarAction(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__VerticalScrollbarAction = slot; } void QListView_virtualbase_VerticalScrollbarAction(void* self, int action) { ( (MiqtVirtualQListView*)(self) )->virtualbase_VerticalScrollbarAction(action); } void QListView_override_virtual_HorizontalScrollbarAction(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__HorizontalScrollbarAction = slot; } void QListView_virtualbase_HorizontalScrollbarAction(void* self, int action) { ( (MiqtVirtualQListView*)(self) )->virtualbase_HorizontalScrollbarAction(action); } void QListView_override_virtual_VerticalScrollbarValueChanged(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__VerticalScrollbarValueChanged = slot; } void QListView_virtualbase_VerticalScrollbarValueChanged(void* self, int value) { ( (MiqtVirtualQListView*)(self) )->virtualbase_VerticalScrollbarValueChanged(value); } void QListView_override_virtual_HorizontalScrollbarValueChanged(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__HorizontalScrollbarValueChanged = slot; } void QListView_virtualbase_HorizontalScrollbarValueChanged(void* self, int value) { ( (MiqtVirtualQListView*)(self) )->virtualbase_HorizontalScrollbarValueChanged(value); } void QListView_override_virtual_CloseEditor(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__CloseEditor = slot; } void QListView_virtualbase_CloseEditor(void* self, QWidget* editor, int hint) { ( (MiqtVirtualQListView*)(self) )->virtualbase_CloseEditor(editor, hint); } void QListView_override_virtual_CommitData(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__CommitData = slot; } void QListView_virtualbase_CommitData(void* self, QWidget* editor) { ( (MiqtVirtualQListView*)(self) )->virtualbase_CommitData(editor); } void QListView_override_virtual_EditorDestroyed(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__EditorDestroyed = slot; } void QListView_virtualbase_EditorDestroyed(void* self, QObject* editor) { ( (MiqtVirtualQListView*)(self) )->virtualbase_EditorDestroyed(editor); } void QListView_override_virtual_Edit2(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__Edit2 = slot; } bool QListView_virtualbase_Edit2(void* self, QModelIndex* index, int trigger, QEvent* event) { return ( (MiqtVirtualQListView*)(self) )->virtualbase_Edit2(index, trigger, event); } void QListView_override_virtual_SelectionCommand(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__SelectionCommand = slot; } int QListView_virtualbase_SelectionCommand(const void* self, QModelIndex* index, QEvent* event) { return ( (const MiqtVirtualQListView*)(self) )->virtualbase_SelectionCommand(index, event); } void QListView_override_virtual_FocusNextPrevChild(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__FocusNextPrevChild = slot; } bool QListView_virtualbase_FocusNextPrevChild(void* self, bool next) { return ( (MiqtVirtualQListView*)(self) )->virtualbase_FocusNextPrevChild(next); } void QListView_override_virtual_ViewportEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__ViewportEvent = slot; } bool QListView_virtualbase_ViewportEvent(void* self, QEvent* event) { return ( (MiqtVirtualQListView*)(self) )->virtualbase_ViewportEvent(event); } void QListView_override_virtual_MousePressEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__MousePressEvent = slot; } void QListView_virtualbase_MousePressEvent(void* self, QMouseEvent* event) { ( (MiqtVirtualQListView*)(self) )->virtualbase_MousePressEvent(event); } void QListView_override_virtual_MouseDoubleClickEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__MouseDoubleClickEvent = slot; } void QListView_virtualbase_MouseDoubleClickEvent(void* self, QMouseEvent* event) { ( (MiqtVirtualQListView*)(self) )->virtualbase_MouseDoubleClickEvent(event); } void QListView_override_virtual_DragEnterEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__DragEnterEvent = slot; } void QListView_virtualbase_DragEnterEvent(void* self, QDragEnterEvent* event) { ( (MiqtVirtualQListView*)(self) )->virtualbase_DragEnterEvent(event); } void QListView_override_virtual_FocusInEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__FocusInEvent = slot; } void QListView_virtualbase_FocusInEvent(void* self, QFocusEvent* event) { ( (MiqtVirtualQListView*)(self) )->virtualbase_FocusInEvent(event); } void QListView_override_virtual_FocusOutEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__FocusOutEvent = slot; } void QListView_virtualbase_FocusOutEvent(void* self, QFocusEvent* event) { ( (MiqtVirtualQListView*)(self) )->virtualbase_FocusOutEvent(event); } void QListView_override_virtual_KeyPressEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__KeyPressEvent = slot; } void QListView_virtualbase_KeyPressEvent(void* self, QKeyEvent* event) { ( (MiqtVirtualQListView*)(self) )->virtualbase_KeyPressEvent(event); } void QListView_override_virtual_InputMethodEvent(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__InputMethodEvent = slot; } void QListView_virtualbase_InputMethodEvent(void* self, QInputMethodEvent* event) { ( (MiqtVirtualQListView*)(self) )->virtualbase_InputMethodEvent(event); } void QListView_override_virtual_EventFilter(void* self, intptr_t slot) { dynamic_cast( (QListView*)(self) )->handle__EventFilter = slot; } bool QListView_virtualbase_EventFilter(void* self, QObject* object, QEvent* event) { return ( (MiqtVirtualQListView*)(self) )->virtualbase_EventFilter(object, event); } void QListView_Delete(QListView* self, bool isSubclass) { if (isSubclass) { delete dynamic_cast( self ); } else { delete self; } }