From 4cba7b0c992558383355afeb81754691c6af23e1 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sun, 20 Apr 2025 13:10:39 -0400 Subject: [PATCH 1/6] config-libraries.go: Add Qt PDF * Closes #200 --- cmd/genbindings/config-libraries.go | 33 +++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/cmd/genbindings/config-libraries.go b/cmd/genbindings/config-libraries.go index f8f4460a..b6cc5d77 100644 --- a/cmd/genbindings/config-libraries.go +++ b/cmd/genbindings/config-libraries.go @@ -200,6 +200,22 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) { ClangMatchSameHeaderDefinitionOnly, ) + // Qt 5 PDF + // Depends on QtCore/Gui/Widgets + generate( + "qt/pdf", + []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtPdf", + "/usr/include/x86_64-linux-gnu/qt5/QtPdfWidgets", + }, + AllowAllHeaders, + clangBin, + pkgConfigCflags("Qt5PdfWidgets"), + outDir, + ClangMatchSameHeaderDefinitionOnly, + ) + + // Depends on QtCore/Gui/Widgets, QPrintSupport generate( "qt-restricted-extras/qscintilla", @@ -434,6 +450,23 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) { ClangMatchSameHeaderDefinitionOnly, ) + + // Qt 6 PDF + generate( + "qt6/pdf", + []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtPdf", + "/usr/include/x86_64-linux-gnu/qt6/QtPdfWidgets", + }, + AllowAllHeaders, + clangBin, + "--std=c++17 "+pkgConfigCflags("Qt6PdfWidgets"), + outDir, + ClangMatchSameHeaderDefinitionOnly, + ) + + + // Qt 6 Charts // Depends on QtCore/Gui/Widgets generate( From 5a39358a1e2967d9ad027f6ea90adfc2bf72c8f8 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sun, 20 Apr 2025 13:11:21 -0400 Subject: [PATCH 2/6] qt: Rebuild (Add Qt PDF) --- qt/pdf/cflags.go | 7 + qt/pdf/gen_qpdfbookmarkmodel.cpp | 2266 ++++++++++++++++++++ qt/pdf/gen_qpdfbookmarkmodel.go | 1964 ++++++++++++++++++ qt/pdf/gen_qpdfbookmarkmodel.h | 187 ++ qt/pdf/gen_qpdfdestination.cpp | 46 + qt/pdf/gen_qpdfdestination.go | 93 + qt/pdf/gen_qpdfdestination.h | 38 + qt/pdf/gen_qpdfdocument.cpp | 560 +++++ qt/pdf/gen_qpdfdocument.go | 590 ++++++ qt/pdf/gen_qpdfdocument.h | 109 + qt/pdf/gen_qpdfdocumentrenderoptions.cpp | 60 + qt/pdf/gen_qpdfdocumentrenderoptions.go | 109 + qt/pdf/gen_qpdfdocumentrenderoptions.h | 43 + qt/pdf/gen_qpdfnamespace.cpp | 11 + qt/pdf/gen_qpdfnamespace.go | 31 + qt/pdf/gen_qpdfnamespace.h | 25 + qt/pdf/gen_qpdfpagenavigation.cpp | 530 +++++ qt/pdf/gen_qpdfpagenavigation.go | 532 +++++ qt/pdf/gen_qpdfpagenavigation.h | 91 + qt/pdf/gen_qpdfpagerenderer.cpp | 508 +++++ qt/pdf/gen_qpdfpagerenderer.go | 499 +++++ qt/pdf/gen_qpdfpagerenderer.h | 90 + qt/pdf/gen_qpdfsearchmodel.cpp | 2181 +++++++++++++++++++ qt/pdf/gen_qpdfsearchmodel.go | 1889 +++++++++++++++++ qt/pdf/gen_qpdfsearchmodel.h | 186 ++ qt/pdf/gen_qpdfsearchresult.cpp | 69 + qt/pdf/gen_qpdfsearchresult.go | 103 + qt/pdf/gen_qpdfsearchresult.h | 39 + qt/pdf/gen_qpdfselection.cpp | 67 + qt/pdf/gen_qpdfselection.go | 108 + qt/pdf/gen_qpdfselection.h | 41 + qt/pdf/gen_qpdfview.cpp | 2295 ++++++++++++++++++++ qt/pdf/gen_qpdfview.go | 1877 +++++++++++++++++ qt/pdf/gen_qpdfview.h | 257 +++ qt6/pdf/cflags.go | 7 + qt6/pdf/gen_qpdfbookmarkmodel.cpp | 2309 +++++++++++++++++++++ qt6/pdf/gen_qpdfbookmarkmodel.go | 1970 ++++++++++++++++++ qt6/pdf/gen_qpdfbookmarkmodel.h | 187 ++ qt6/pdf/gen_qpdfdocument.cpp | 554 +++++ qt6/pdf/gen_qpdfdocument.go | 595 ++++++ qt6/pdf/gen_qpdfdocument.h | 112 + qt6/pdf/gen_qpdfdocumentrenderoptions.cpp | 60 + qt6/pdf/gen_qpdfdocumentrenderoptions.go | 131 ++ qt6/pdf/gen_qpdfdocumentrenderoptions.h | 43 + qt6/pdf/gen_qpdflink.cpp | 114 + qt6/pdf/gen_qpdflink.go | 146 ++ qt6/pdf/gen_qpdflink.h | 50 + qt6/pdf/gen_qpdfpagenavigator.cpp | 538 +++++ qt6/pdf/gen_qpdfpagenavigator.go | 555 +++++ qt6/pdf/gen_qpdfpagenavigator.h | 96 + qt6/pdf/gen_qpdfpagerenderer.cpp | 475 +++++ qt6/pdf/gen_qpdfpagerenderer.go | 468 +++++ qt6/pdf/gen_qpdfpagerenderer.h | 87 + qt6/pdf/gen_qpdfsearchmodel.cpp | 2245 ++++++++++++++++++++ qt6/pdf/gen_qpdfsearchmodel.go | 1927 +++++++++++++++++ qt6/pdf/gen_qpdfsearchmodel.h | 190 ++ qt6/pdf/gen_qpdfselection.cpp | 67 + qt6/pdf/gen_qpdfselection.go | 108 + qt6/pdf/gen_qpdfselection.h | 41 + qt6/pdf/gen_qpdfview.cpp | 2286 ++++++++++++++++++++ qt6/pdf/gen_qpdfview.go | 1860 +++++++++++++++++ qt6/pdf/gen_qpdfview.h | 257 +++ 62 files changed, 34979 insertions(+) create mode 100644 qt/pdf/cflags.go create mode 100644 qt/pdf/gen_qpdfbookmarkmodel.cpp create mode 100644 qt/pdf/gen_qpdfbookmarkmodel.go create mode 100644 qt/pdf/gen_qpdfbookmarkmodel.h create mode 100644 qt/pdf/gen_qpdfdestination.cpp create mode 100644 qt/pdf/gen_qpdfdestination.go create mode 100644 qt/pdf/gen_qpdfdestination.h create mode 100644 qt/pdf/gen_qpdfdocument.cpp create mode 100644 qt/pdf/gen_qpdfdocument.go create mode 100644 qt/pdf/gen_qpdfdocument.h create mode 100644 qt/pdf/gen_qpdfdocumentrenderoptions.cpp create mode 100644 qt/pdf/gen_qpdfdocumentrenderoptions.go create mode 100644 qt/pdf/gen_qpdfdocumentrenderoptions.h create mode 100644 qt/pdf/gen_qpdfnamespace.cpp create mode 100644 qt/pdf/gen_qpdfnamespace.go create mode 100644 qt/pdf/gen_qpdfnamespace.h create mode 100644 qt/pdf/gen_qpdfpagenavigation.cpp create mode 100644 qt/pdf/gen_qpdfpagenavigation.go create mode 100644 qt/pdf/gen_qpdfpagenavigation.h create mode 100644 qt/pdf/gen_qpdfpagerenderer.cpp create mode 100644 qt/pdf/gen_qpdfpagerenderer.go create mode 100644 qt/pdf/gen_qpdfpagerenderer.h create mode 100644 qt/pdf/gen_qpdfsearchmodel.cpp create mode 100644 qt/pdf/gen_qpdfsearchmodel.go create mode 100644 qt/pdf/gen_qpdfsearchmodel.h create mode 100644 qt/pdf/gen_qpdfsearchresult.cpp create mode 100644 qt/pdf/gen_qpdfsearchresult.go create mode 100644 qt/pdf/gen_qpdfsearchresult.h create mode 100644 qt/pdf/gen_qpdfselection.cpp create mode 100644 qt/pdf/gen_qpdfselection.go create mode 100644 qt/pdf/gen_qpdfselection.h create mode 100644 qt/pdf/gen_qpdfview.cpp create mode 100644 qt/pdf/gen_qpdfview.go create mode 100644 qt/pdf/gen_qpdfview.h create mode 100644 qt6/pdf/cflags.go create mode 100644 qt6/pdf/gen_qpdfbookmarkmodel.cpp create mode 100644 qt6/pdf/gen_qpdfbookmarkmodel.go create mode 100644 qt6/pdf/gen_qpdfbookmarkmodel.h create mode 100644 qt6/pdf/gen_qpdfdocument.cpp create mode 100644 qt6/pdf/gen_qpdfdocument.go create mode 100644 qt6/pdf/gen_qpdfdocument.h create mode 100644 qt6/pdf/gen_qpdfdocumentrenderoptions.cpp create mode 100644 qt6/pdf/gen_qpdfdocumentrenderoptions.go create mode 100644 qt6/pdf/gen_qpdfdocumentrenderoptions.h create mode 100644 qt6/pdf/gen_qpdflink.cpp create mode 100644 qt6/pdf/gen_qpdflink.go create mode 100644 qt6/pdf/gen_qpdflink.h create mode 100644 qt6/pdf/gen_qpdfpagenavigator.cpp create mode 100644 qt6/pdf/gen_qpdfpagenavigator.go create mode 100644 qt6/pdf/gen_qpdfpagenavigator.h create mode 100644 qt6/pdf/gen_qpdfpagerenderer.cpp create mode 100644 qt6/pdf/gen_qpdfpagerenderer.go create mode 100644 qt6/pdf/gen_qpdfpagerenderer.h create mode 100644 qt6/pdf/gen_qpdfsearchmodel.cpp create mode 100644 qt6/pdf/gen_qpdfsearchmodel.go create mode 100644 qt6/pdf/gen_qpdfsearchmodel.h create mode 100644 qt6/pdf/gen_qpdfselection.cpp create mode 100644 qt6/pdf/gen_qpdfselection.go create mode 100644 qt6/pdf/gen_qpdfselection.h create mode 100644 qt6/pdf/gen_qpdfview.cpp create mode 100644 qt6/pdf/gen_qpdfview.go create mode 100644 qt6/pdf/gen_qpdfview.h diff --git a/qt/pdf/cflags.go b/qt/pdf/cflags.go new file mode 100644 index 00000000..7b7510b1 --- /dev/null +++ b/qt/pdf/cflags.go @@ -0,0 +1,7 @@ +package pdf + +/* +#cgo pkg-config: Qt5PdfWidgets +*/ +import "C" + diff --git a/qt/pdf/gen_qpdfbookmarkmodel.cpp b/qt/pdf/gen_qpdfbookmarkmodel.cpp new file mode 100644 index 00000000..39fbbde8 --- /dev/null +++ b/qt/pdf/gen_qpdfbookmarkmodel.cpp @@ -0,0 +1,2266 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qpdfbookmarkmodel.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QPdfBookmarkModel_documentChanged(intptr_t, QPdfDocument*); +void miqt_exec_callback_QPdfBookmarkModel_structureModeChanged(intptr_t, int); +QVariant* miqt_exec_callback_QPdfBookmarkModel_data(const QPdfBookmarkModel*, intptr_t, QModelIndex*, int); +QModelIndex* miqt_exec_callback_QPdfBookmarkModel_index(const QPdfBookmarkModel*, intptr_t, int, int, QModelIndex*); +QModelIndex* miqt_exec_callback_QPdfBookmarkModel_parent(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +int miqt_exec_callback_QPdfBookmarkModel_rowCount(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +int miqt_exec_callback_QPdfBookmarkModel_columnCount(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +struct miqt_map /* of int to struct miqt_string */ miqt_exec_callback_QPdfBookmarkModel_roleNames(const QPdfBookmarkModel*, intptr_t); +QModelIndex* miqt_exec_callback_QPdfBookmarkModel_sibling(const QPdfBookmarkModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_hasChildren(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_setData(QPdfBookmarkModel*, intptr_t, QModelIndex*, QVariant*, int); +QVariant* miqt_exec_callback_QPdfBookmarkModel_headerData(const QPdfBookmarkModel*, intptr_t, int, int, int); +bool miqt_exec_callback_QPdfBookmarkModel_setHeaderData(QPdfBookmarkModel*, intptr_t, int, int, QVariant*, int); +struct miqt_map /* of int to QVariant* */ miqt_exec_callback_QPdfBookmarkModel_itemData(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_setItemData(QPdfBookmarkModel*, intptr_t, QModelIndex*, struct miqt_map /* of int to QVariant* */ ); +struct miqt_array /* of struct miqt_string */ miqt_exec_callback_QPdfBookmarkModel_mimeTypes(const QPdfBookmarkModel*, intptr_t); +QMimeData* miqt_exec_callback_QPdfBookmarkModel_mimeData(const QPdfBookmarkModel*, intptr_t, struct miqt_array /* of QModelIndex* */ ); +bool miqt_exec_callback_QPdfBookmarkModel_canDropMimeData(const QPdfBookmarkModel*, intptr_t, QMimeData*, int, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_dropMimeData(QPdfBookmarkModel*, intptr_t, QMimeData*, int, int, int, QModelIndex*); +int miqt_exec_callback_QPdfBookmarkModel_supportedDropActions(const QPdfBookmarkModel*, intptr_t); +int miqt_exec_callback_QPdfBookmarkModel_supportedDragActions(const QPdfBookmarkModel*, intptr_t); +bool miqt_exec_callback_QPdfBookmarkModel_insertRows(QPdfBookmarkModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_insertColumns(QPdfBookmarkModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_removeRows(QPdfBookmarkModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_removeColumns(QPdfBookmarkModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_moveRows(QPdfBookmarkModel*, intptr_t, QModelIndex*, int, int, QModelIndex*, int); +bool miqt_exec_callback_QPdfBookmarkModel_moveColumns(QPdfBookmarkModel*, intptr_t, QModelIndex*, int, int, QModelIndex*, int); +void miqt_exec_callback_QPdfBookmarkModel_fetchMore(QPdfBookmarkModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_canFetchMore(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +int miqt_exec_callback_QPdfBookmarkModel_flags(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +void miqt_exec_callback_QPdfBookmarkModel_sort(QPdfBookmarkModel*, intptr_t, int, int); +QModelIndex* miqt_exec_callback_QPdfBookmarkModel_buddy(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +struct miqt_array /* of QModelIndex* */ miqt_exec_callback_QPdfBookmarkModel_match(const QPdfBookmarkModel*, intptr_t, QModelIndex*, int, QVariant*, int, int); +QSize* miqt_exec_callback_QPdfBookmarkModel_span(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_submit(QPdfBookmarkModel*, intptr_t); +void miqt_exec_callback_QPdfBookmarkModel_revert(QPdfBookmarkModel*, intptr_t); +bool miqt_exec_callback_QPdfBookmarkModel_event(QPdfBookmarkModel*, intptr_t, QEvent*); +bool miqt_exec_callback_QPdfBookmarkModel_eventFilter(QPdfBookmarkModel*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QPdfBookmarkModel_timerEvent(QPdfBookmarkModel*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QPdfBookmarkModel_childEvent(QPdfBookmarkModel*, intptr_t, QChildEvent*); +void miqt_exec_callback_QPdfBookmarkModel_customEvent(QPdfBookmarkModel*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfBookmarkModel_connectNotify(QPdfBookmarkModel*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QPdfBookmarkModel_disconnectNotify(QPdfBookmarkModel*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQPdfBookmarkModel final : public QPdfBookmarkModel { +public: + + MiqtVirtualQPdfBookmarkModel(): QPdfBookmarkModel() {}; + MiqtVirtualQPdfBookmarkModel(QObject* parent): QPdfBookmarkModel(parent) {}; + + virtual ~MiqtVirtualQPdfBookmarkModel() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__data = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant data(const QModelIndex& index, int role) const override { + if (handle__data == 0) { + return QPdfBookmarkModel::data(index, role); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + int sigval2 = role; + + QVariant* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_data(this, handle__data, sigval1, sigval2); + + return *callback_return_value; + } + + friend QVariant* QPdfBookmarkModel_virtualbase_data(const void* self, QModelIndex* index, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__index = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex index(int row, int column, const QModelIndex& parent) const override { + if (handle__index == 0) { + return QPdfBookmarkModel::index(row, column, parent); + } + + int sigval1 = row; + int sigval2 = column; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_index(this, handle__index, sigval1, sigval2, sigval3); + + return *callback_return_value; + } + + friend QModelIndex* QPdfBookmarkModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__parent = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex parent(const QModelIndex& index) const override { + if (handle__parent == 0) { + return QPdfBookmarkModel::parent(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_parent(this, handle__parent, sigval1); + + return *callback_return_value; + } + + friend QModelIndex* QPdfBookmarkModel_virtualbase_parent(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__rowCount = 0; + + // Subclass to allow providing a Go implementation + virtual int rowCount(const QModelIndex& parent) const override { + if (handle__rowCount == 0) { + return QPdfBookmarkModel::rowCount(parent); + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + int callback_return_value = miqt_exec_callback_QPdfBookmarkModel_rowCount(this, handle__rowCount, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfBookmarkModel_virtualbase_rowCount(const void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__columnCount = 0; + + // Subclass to allow providing a Go implementation + virtual int columnCount(const QModelIndex& parent) const override { + if (handle__columnCount == 0) { + return QPdfBookmarkModel::columnCount(parent); + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + int callback_return_value = miqt_exec_callback_QPdfBookmarkModel_columnCount(this, handle__columnCount, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfBookmarkModel_virtualbase_columnCount(const void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__roleNames = 0; + + // Subclass to allow providing a Go implementation + virtual QHash roleNames() const override { + if (handle__roleNames == 0) { + return QPdfBookmarkModel::roleNames(); + } + + + struct miqt_map /* of int to struct miqt_string */ callback_return_value = miqt_exec_callback_QPdfBookmarkModel_roleNames(this, handle__roleNames); + QHash callback_return_value_QMap; + callback_return_value_QMap.reserve(callback_return_value.len); + int* callback_return_value_karr = static_cast(callback_return_value.keys); + struct miqt_string* callback_return_value_varr = static_cast(callback_return_value.values); + for(size_t i = 0; i < callback_return_value.len; ++i) { + QByteArray callback_return_value_varr_i_QByteArray(callback_return_value_varr[i].data, callback_return_value_varr[i].len); + callback_return_value_QMap[static_cast(callback_return_value_karr[i])] = callback_return_value_varr_i_QByteArray; + } + + return callback_return_value_QMap; + } + + friend struct miqt_map /* of int to struct miqt_string */ QPdfBookmarkModel_virtualbase_roleNames(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__sibling = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex sibling(int row, int column, const QModelIndex& idx) const override { + if (handle__sibling == 0) { + return QPdfBookmarkModel::sibling(row, column, idx); + } + + int sigval1 = row; + int sigval2 = column; + const QModelIndex& idx_ret = idx; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&idx_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_sibling(this, handle__sibling, sigval1, sigval2, sigval3); + + return *callback_return_value; + } + + friend QModelIndex* QPdfBookmarkModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx); + + // cgo.Handle value for overwritten implementation + intptr_t handle__hasChildren = 0; + + // Subclass to allow providing a Go implementation + virtual bool hasChildren(const QModelIndex& parent) const override { + if (handle__hasChildren == 0) { + return QPdfBookmarkModel::hasChildren(parent); + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_hasChildren(this, handle__hasChildren, sigval1); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_hasChildren(const void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setData = 0; + + // Subclass to allow providing a Go implementation + virtual bool setData(const QModelIndex& index, const QVariant& value, int role) override { + if (handle__setData == 0) { + return QPdfBookmarkModel::setData(index, value, role); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval2 = const_cast(&value_ret); + int sigval3 = role; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_setData(this, handle__setData, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__headerData = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant headerData(int section, Qt::Orientation orientation, int role) const override { + if (handle__headerData == 0) { + return QPdfBookmarkModel::headerData(section, orientation, role); + } + + int sigval1 = section; + Qt::Orientation orientation_ret = orientation; + int sigval2 = static_cast(orientation_ret); + int sigval3 = role; + + QVariant* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_headerData(this, handle__headerData, sigval1, sigval2, sigval3); + + return *callback_return_value; + } + + friend QVariant* QPdfBookmarkModel_virtualbase_headerData(const void* self, int section, int orientation, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setHeaderData = 0; + + // Subclass to allow providing a Go implementation + virtual bool setHeaderData(int section, Qt::Orientation orientation, const QVariant& value, int role) override { + if (handle__setHeaderData == 0) { + return QPdfBookmarkModel::setHeaderData(section, orientation, value, role); + } + + int sigval1 = section; + Qt::Orientation orientation_ret = orientation; + int sigval2 = static_cast(orientation_ret); + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval3 = const_cast(&value_ret); + int sigval4 = role; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_setHeaderData(this, handle__setHeaderData, sigval1, sigval2, sigval3, sigval4); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__itemData = 0; + + // Subclass to allow providing a Go implementation + virtual QMap itemData(const QModelIndex& index) const override { + if (handle__itemData == 0) { + return QPdfBookmarkModel::itemData(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + struct miqt_map /* of int to QVariant* */ callback_return_value = miqt_exec_callback_QPdfBookmarkModel_itemData(this, handle__itemData, sigval1); + QMap callback_return_value_QMap; + int* callback_return_value_karr = static_cast(callback_return_value.keys); + QVariant** callback_return_value_varr = static_cast(callback_return_value.values); + for(size_t i = 0; i < callback_return_value.len; ++i) { + callback_return_value_QMap[static_cast(callback_return_value_karr[i])] = *(callback_return_value_varr[i]); + } + + return callback_return_value_QMap; + } + + friend struct miqt_map /* of int to QVariant* */ QPdfBookmarkModel_virtualbase_itemData(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setItemData = 0; + + // Subclass to allow providing a Go implementation + virtual bool setItemData(const QModelIndex& index, const QMap& roles) override { + if (handle__setItemData == 0) { + return QPdfBookmarkModel::setItemData(index, roles); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + const QMap& roles_ret = roles; + // Convert QMap<> from C++ memory to manually-managed C memory + int* roles_karr = static_cast(malloc(sizeof(int) * roles_ret.size())); + QVariant** roles_varr = static_cast(malloc(sizeof(QVariant*) * roles_ret.size())); + int roles_ctr = 0; + for (auto roles_itr = roles_ret.keyValueBegin(); roles_itr != roles_ret.keyValueEnd(); ++roles_itr) { + roles_karr[roles_ctr] = roles_itr->first; + roles_varr[roles_ctr] = new QVariant(roles_itr->second); + roles_ctr++; + } + struct miqt_map roles_out; + roles_out.len = roles_ret.size(); + roles_out.keys = static_cast(roles_karr); + roles_out.values = static_cast(roles_varr); + struct miqt_map /* of int to QVariant* */ sigval2 = roles_out; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_setItemData(this, handle__setItemData, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */ roles); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mimeTypes = 0; + + // Subclass to allow providing a Go implementation + virtual QStringList mimeTypes() const override { + if (handle__mimeTypes == 0) { + return QPdfBookmarkModel::mimeTypes(); + } + + + struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QPdfBookmarkModel_mimeTypes(this, handle__mimeTypes); + QStringList callback_return_value_QList; + callback_return_value_QList.reserve(callback_return_value.len); + struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); + for(size_t i = 0; i < callback_return_value.len; ++i) { + QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); + callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + } + + return callback_return_value_QList; + } + + friend struct miqt_array /* of struct miqt_string */ QPdfBookmarkModel_virtualbase_mimeTypes(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mimeData = 0; + + // Subclass to allow providing a Go implementation + virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + if (handle__mimeData == 0) { + return QPdfBookmarkModel::mimeData(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; + + QMimeData* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_mimeData(this, handle__mimeData, sigval1); + + return callback_return_value; + } + + friend QMimeData* QPdfBookmarkModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes); + + // cgo.Handle value for overwritten implementation + intptr_t handle__canDropMimeData = 0; + + // Subclass to allow providing a Go implementation + virtual bool canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const override { + if (handle__canDropMimeData == 0) { + return QPdfBookmarkModel::canDropMimeData(data, action, row, column, parent); + } + + QMimeData* sigval1 = (QMimeData*) data; + Qt::DropAction action_ret = action; + int sigval2 = static_cast(action_ret); + int sigval3 = row; + int sigval4 = column; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval5 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_canDropMimeData(this, handle__canDropMimeData, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__dropMimeData = 0; + + // Subclass to allow providing a Go implementation + virtual bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override { + if (handle__dropMimeData == 0) { + return QPdfBookmarkModel::dropMimeData(data, action, row, column, parent); + } + + QMimeData* sigval1 = (QMimeData*) data; + Qt::DropAction action_ret = action; + int sigval2 = static_cast(action_ret); + int sigval3 = row; + int sigval4 = column; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval5 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_dropMimeData(this, handle__dropMimeData, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__supportedDropActions = 0; + + // Subclass to allow providing a Go implementation + virtual Qt::DropActions supportedDropActions() const override { + if (handle__supportedDropActions == 0) { + return QPdfBookmarkModel::supportedDropActions(); + } + + + int callback_return_value = miqt_exec_callback_QPdfBookmarkModel_supportedDropActions(this, handle__supportedDropActions); + + return static_cast(callback_return_value); + } + + friend int QPdfBookmarkModel_virtualbase_supportedDropActions(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__supportedDragActions = 0; + + // Subclass to allow providing a Go implementation + virtual Qt::DropActions supportedDragActions() const override { + if (handle__supportedDragActions == 0) { + return QPdfBookmarkModel::supportedDragActions(); + } + + + int callback_return_value = miqt_exec_callback_QPdfBookmarkModel_supportedDragActions(this, handle__supportedDragActions); + + return static_cast(callback_return_value); + } + + friend int QPdfBookmarkModel_virtualbase_supportedDragActions(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__insertRows = 0; + + // Subclass to allow providing a Go implementation + virtual bool insertRows(int row, int count, const QModelIndex& parent) override { + if (handle__insertRows == 0) { + return QPdfBookmarkModel::insertRows(row, count, parent); + } + + int sigval1 = row; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_insertRows(this, handle__insertRows, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__insertColumns = 0; + + // Subclass to allow providing a Go implementation + virtual bool insertColumns(int column, int count, const QModelIndex& parent) override { + if (handle__insertColumns == 0) { + return QPdfBookmarkModel::insertColumns(column, count, parent); + } + + int sigval1 = column; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_insertColumns(this, handle__insertColumns, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__removeRows = 0; + + // Subclass to allow providing a Go implementation + virtual bool removeRows(int row, int count, const QModelIndex& parent) override { + if (handle__removeRows == 0) { + return QPdfBookmarkModel::removeRows(row, count, parent); + } + + int sigval1 = row; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_removeRows(this, handle__removeRows, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__removeColumns = 0; + + // Subclass to allow providing a Go implementation + virtual bool removeColumns(int column, int count, const QModelIndex& parent) override { + if (handle__removeColumns == 0) { + return QPdfBookmarkModel::removeColumns(column, count, parent); + } + + int sigval1 = column; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_removeColumns(this, handle__removeColumns, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__moveRows = 0; + + // Subclass to allow providing a Go implementation + virtual bool moveRows(const QModelIndex& sourceParent, int sourceRow, int count, const QModelIndex& destinationParent, int destinationChild) override { + if (handle__moveRows == 0) { + return QPdfBookmarkModel::moveRows(sourceParent, sourceRow, count, destinationParent, destinationChild); + } + + const QModelIndex& sourceParent_ret = sourceParent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&sourceParent_ret); + int sigval2 = sourceRow; + int sigval3 = count; + const QModelIndex& destinationParent_ret = destinationParent; + // Cast returned reference into pointer + QModelIndex* sigval4 = const_cast(&destinationParent_ret); + int sigval5 = destinationChild; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_moveRows(this, handle__moveRows, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild); + + // cgo.Handle value for overwritten implementation + intptr_t handle__moveColumns = 0; + + // Subclass to allow providing a Go implementation + virtual bool moveColumns(const QModelIndex& sourceParent, int sourceColumn, int count, const QModelIndex& destinationParent, int destinationChild) override { + if (handle__moveColumns == 0) { + return QPdfBookmarkModel::moveColumns(sourceParent, sourceColumn, count, destinationParent, destinationChild); + } + + const QModelIndex& sourceParent_ret = sourceParent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&sourceParent_ret); + int sigval2 = sourceColumn; + int sigval3 = count; + const QModelIndex& destinationParent_ret = destinationParent; + // Cast returned reference into pointer + QModelIndex* sigval4 = const_cast(&destinationParent_ret); + int sigval5 = destinationChild; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_moveColumns(this, handle__moveColumns, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild); + + // cgo.Handle value for overwritten implementation + intptr_t handle__fetchMore = 0; + + // Subclass to allow providing a Go implementation + virtual void fetchMore(const QModelIndex& parent) override { + if (handle__fetchMore == 0) { + QPdfBookmarkModel::fetchMore(parent); + return; + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + miqt_exec_callback_QPdfBookmarkModel_fetchMore(this, handle__fetchMore, sigval1); + + + } + + friend void QPdfBookmarkModel_virtualbase_fetchMore(void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__canFetchMore = 0; + + // Subclass to allow providing a Go implementation + virtual bool canFetchMore(const QModelIndex& parent) const override { + if (handle__canFetchMore == 0) { + return QPdfBookmarkModel::canFetchMore(parent); + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_canFetchMore(this, handle__canFetchMore, sigval1); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__flags = 0; + + // Subclass to allow providing a Go implementation + virtual Qt::ItemFlags flags(const QModelIndex& index) const override { + if (handle__flags == 0) { + return QPdfBookmarkModel::flags(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + int callback_return_value = miqt_exec_callback_QPdfBookmarkModel_flags(this, handle__flags, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfBookmarkModel_virtualbase_flags(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__sort = 0; + + // Subclass to allow providing a Go implementation + virtual void sort(int column, Qt::SortOrder order) override { + if (handle__sort == 0) { + QPdfBookmarkModel::sort(column, order); + return; + } + + int sigval1 = column; + Qt::SortOrder order_ret = order; + int sigval2 = static_cast(order_ret); + + miqt_exec_callback_QPdfBookmarkModel_sort(this, handle__sort, sigval1, sigval2); + + + } + + friend void QPdfBookmarkModel_virtualbase_sort(void* self, int column, int order); + + // cgo.Handle value for overwritten implementation + intptr_t handle__buddy = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex buddy(const QModelIndex& index) const override { + if (handle__buddy == 0) { + return QPdfBookmarkModel::buddy(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_buddy(this, handle__buddy, sigval1); + + return *callback_return_value; + } + + friend QModelIndex* QPdfBookmarkModel_virtualbase_buddy(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__match = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + if (handle__match == 0) { + return QPdfBookmarkModel::match(start, role, value, hits, flags); + } + + const QModelIndex& start_ret = start; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&start_ret); + int sigval2 = role; + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval3 = const_cast(&value_ret); + int sigval4 = hits; + Qt::MatchFlags flags_ret = flags; + int sigval5 = static_cast(flags_ret); + + struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QPdfBookmarkModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); + 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; + } + + friend struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); + + // cgo.Handle value for overwritten implementation + intptr_t handle__span = 0; + + // Subclass to allow providing a Go implementation + virtual QSize span(const QModelIndex& index) const override { + if (handle__span == 0) { + return QPdfBookmarkModel::span(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + QSize* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_span(this, handle__span, sigval1); + + return *callback_return_value; + } + + friend QSize* QPdfBookmarkModel_virtualbase_span(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__submit = 0; + + // Subclass to allow providing a Go implementation + virtual bool submit() override { + if (handle__submit == 0) { + return QPdfBookmarkModel::submit(); + } + + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_submit(this, handle__submit); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_submit(void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__revert = 0; + + // Subclass to allow providing a Go implementation + virtual void revert() override { + if (handle__revert == 0) { + QPdfBookmarkModel::revert(); + return; + } + + + miqt_exec_callback_QPdfBookmarkModel_revert(this, handle__revert); + + + } + + friend void QPdfBookmarkModel_virtualbase_revert(void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QPdfBookmarkModel::event(event); + } + + QEvent* sigval1 = event; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_event(this, handle__event, sigval1); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QPdfBookmarkModel::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_eventFilter(this, handle__eventFilter, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__timerEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void timerEvent(QTimerEvent* event) override { + if (handle__timerEvent == 0) { + QPdfBookmarkModel::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + + miqt_exec_callback_QPdfBookmarkModel_timerEvent(this, handle__timerEvent, sigval1); + + + } + + friend void QPdfBookmarkModel_virtualbase_timerEvent(void* self, QTimerEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__childEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void childEvent(QChildEvent* event) override { + if (handle__childEvent == 0) { + QPdfBookmarkModel::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + + miqt_exec_callback_QPdfBookmarkModel_childEvent(this, handle__childEvent, sigval1); + + + } + + friend void QPdfBookmarkModel_virtualbase_childEvent(void* self, QChildEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__customEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void customEvent(QEvent* event) override { + if (handle__customEvent == 0) { + QPdfBookmarkModel::customEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfBookmarkModel_customEvent(this, handle__customEvent, sigval1); + + + } + + friend void QPdfBookmarkModel_virtualbase_customEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__connectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void connectNotify(const QMetaMethod& signal) override { + if (handle__connectNotify == 0) { + QPdfBookmarkModel::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfBookmarkModel_connectNotify(this, handle__connectNotify, sigval1); + + + } + + friend void QPdfBookmarkModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); + + // cgo.Handle value for overwritten implementation + intptr_t handle__disconnectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void disconnectNotify(const QMetaMethod& signal) override { + if (handle__disconnectNotify == 0) { + QPdfBookmarkModel::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfBookmarkModel_disconnectNotify(this, handle__disconnectNotify, sigval1); + + + } + + friend void QPdfBookmarkModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend void QPdfBookmarkModel_protectedbase_resetInternalData(bool* _dynamic_cast_ok, void* self); + friend QModelIndex* QPdfBookmarkModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column); + friend void QPdfBookmarkModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */ indexes, QDataStream* stream); + friend bool QPdfBookmarkModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream); + friend void QPdfBookmarkModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfBookmarkModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self); + friend void QPdfBookmarkModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfBookmarkModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self); + friend bool QPdfBookmarkModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow); + friend void QPdfBookmarkModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self); + friend void QPdfBookmarkModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfBookmarkModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self); + friend void QPdfBookmarkModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfBookmarkModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self); + friend bool QPdfBookmarkModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn); + friend void QPdfBookmarkModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self); + friend void QPdfBookmarkModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self); + friend void QPdfBookmarkModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self); + friend void QPdfBookmarkModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to); + friend void QPdfBookmarkModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */ from, struct miqt_array /* of QModelIndex* */ to); + friend struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self); + friend QObject* QPdfBookmarkModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QPdfBookmarkModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QPdfBookmarkModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QPdfBookmarkModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QPdfBookmarkModel* QPdfBookmarkModel_new() { + return new MiqtVirtualQPdfBookmarkModel(); +} + +QPdfBookmarkModel* QPdfBookmarkModel_new2(QObject* parent) { + return new MiqtVirtualQPdfBookmarkModel(parent); +} + +void QPdfBookmarkModel_virtbase(QPdfBookmarkModel* src, QAbstractItemModel** outptr_QAbstractItemModel) { + *outptr_QAbstractItemModel = static_cast(src); +} + +QMetaObject* QPdfBookmarkModel_metaObject(const QPdfBookmarkModel* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QPdfBookmarkModel_metacast(QPdfBookmarkModel* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QPdfBookmarkModel_tr(const char* s) { + QString _ret = QPdfBookmarkModel::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 QPdfBookmarkModel_trUtf8(const char* s) { + QString _ret = QPdfBookmarkModel::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; +} + +QPdfDocument* QPdfBookmarkModel_document(const QPdfBookmarkModel* self) { + return self->document(); +} + +void QPdfBookmarkModel_setDocument(QPdfBookmarkModel* self, QPdfDocument* document) { + self->setDocument(document); +} + +int QPdfBookmarkModel_structureMode(const QPdfBookmarkModel* self) { + QPdfBookmarkModel::StructureMode _ret = self->structureMode(); + return static_cast(_ret); +} + +void QPdfBookmarkModel_setStructureMode(QPdfBookmarkModel* self, int mode) { + self->setStructureMode(static_cast(mode)); +} + +QVariant* QPdfBookmarkModel_data(const QPdfBookmarkModel* self, QModelIndex* index, int role) { + return new QVariant(self->data(*index, static_cast(role))); +} + +QModelIndex* QPdfBookmarkModel_index(const QPdfBookmarkModel* self, int row, int column, QModelIndex* parent) { + return new QModelIndex(self->index(static_cast(row), static_cast(column), *parent)); +} + +QModelIndex* QPdfBookmarkModel_parent(const QPdfBookmarkModel* self, QModelIndex* index) { + return new QModelIndex(self->parent(*index)); +} + +int QPdfBookmarkModel_rowCount(const QPdfBookmarkModel* self, QModelIndex* parent) { + return self->rowCount(*parent); +} + +int QPdfBookmarkModel_columnCount(const QPdfBookmarkModel* self, QModelIndex* parent) { + return self->columnCount(*parent); +} + +struct miqt_map /* of int to struct miqt_string */ QPdfBookmarkModel_roleNames(const QPdfBookmarkModel* self) { + QHash _ret = self->roleNames(); + // Convert QMap<> from C++ memory to manually-managed C memory + int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); + struct miqt_string* _varr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + _karr[_ctr] = _itr->first; + QByteArray _hashval_qb = _itr->second; + struct miqt_string _hashval_ms; + _hashval_ms.len = _hashval_qb.length(); + _hashval_ms.data = static_cast(malloc(_hashval_ms.len)); + memcpy(_hashval_ms.data, _hashval_qb.data(), _hashval_ms.len); + _varr[_ctr] = _hashval_ms; + _ctr++; + } + struct miqt_map _out; + _out.len = _ret.size(); + _out.keys = static_cast(_karr); + _out.values = static_cast(_varr); + return _out; +} + +void QPdfBookmarkModel_documentChanged(QPdfBookmarkModel* self, QPdfDocument* document) { + self->documentChanged(document); +} + +void QPdfBookmarkModel_connect_documentChanged(QPdfBookmarkModel* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel::connect(self, static_cast(&QPdfBookmarkModel::documentChanged), self, [=](QPdfDocument* document) { + QPdfDocument* sigval1 = document; + miqt_exec_callback_QPdfBookmarkModel_documentChanged(slot, sigval1); + }); +} + +void QPdfBookmarkModel_structureModeChanged(QPdfBookmarkModel* self, int structureMode) { + self->structureModeChanged(static_cast(structureMode)); +} + +void QPdfBookmarkModel_connect_structureModeChanged(QPdfBookmarkModel* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel::connect(self, static_cast(&QPdfBookmarkModel::structureModeChanged), self, [=](QPdfBookmarkModel::StructureMode structureMode) { + QPdfBookmarkModel::StructureMode structureMode_ret = structureMode; + int sigval1 = static_cast(structureMode_ret); + miqt_exec_callback_QPdfBookmarkModel_structureModeChanged(slot, sigval1); + }); +} + +struct miqt_string QPdfBookmarkModel_tr2(const char* s, const char* c) { + QString _ret = QPdfBookmarkModel::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 QPdfBookmarkModel_tr3(const char* s, const char* c, int n) { + QString _ret = QPdfBookmarkModel::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 QPdfBookmarkModel_trUtf82(const char* s, const char* c) { + QString _ret = QPdfBookmarkModel::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 QPdfBookmarkModel_trUtf83(const char* s, const char* c, int n) { + QString _ret = QPdfBookmarkModel::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; +} + +bool QPdfBookmarkModel_override_virtual_data(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__data = slot; + return true; +} + +QVariant* QPdfBookmarkModel_virtualbase_data(const void* self, QModelIndex* index, int role) { + + return new QVariant(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::data(*index, static_cast(role))); + +} + +bool QPdfBookmarkModel_override_virtual_index(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__index = slot; + return true; +} + +QModelIndex* QPdfBookmarkModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent) { + + return new QModelIndex(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::index(static_cast(row), static_cast(column), *parent)); + +} + +bool QPdfBookmarkModel_override_virtual_parent(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__parent = slot; + return true; +} + +QModelIndex* QPdfBookmarkModel_virtualbase_parent(const void* self, QModelIndex* index) { + + return new QModelIndex(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::parent(*index)); + +} + +bool QPdfBookmarkModel_override_virtual_rowCount(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__rowCount = slot; + return true; +} + +int QPdfBookmarkModel_virtualbase_rowCount(const void* self, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::rowCount(*parent); + +} + +bool QPdfBookmarkModel_override_virtual_columnCount(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__columnCount = slot; + return true; +} + +int QPdfBookmarkModel_virtualbase_columnCount(const void* self, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::columnCount(*parent); + +} + +bool QPdfBookmarkModel_override_virtual_roleNames(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__roleNames = slot; + return true; +} + +struct miqt_map /* of int to struct miqt_string */ QPdfBookmarkModel_virtualbase_roleNames(const void* self) { + + QHash _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::roleNames(); + // Convert QMap<> from C++ memory to manually-managed C memory + int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); + struct miqt_string* _varr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + _karr[_ctr] = _itr->first; + QByteArray _hashval_qb = _itr->second; + struct miqt_string _hashval_ms; + _hashval_ms.len = _hashval_qb.length(); + _hashval_ms.data = static_cast(malloc(_hashval_ms.len)); + memcpy(_hashval_ms.data, _hashval_qb.data(), _hashval_ms.len); + _varr[_ctr] = _hashval_ms; + _ctr++; + } + struct miqt_map _out; + _out.len = _ret.size(); + _out.keys = static_cast(_karr); + _out.values = static_cast(_varr); + return _out; + +} + +bool QPdfBookmarkModel_override_virtual_sibling(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__sibling = slot; + return true; +} + +QModelIndex* QPdfBookmarkModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx) { + + return new QModelIndex(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::sibling(static_cast(row), static_cast(column), *idx)); + +} + +bool QPdfBookmarkModel_override_virtual_hasChildren(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__hasChildren = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_hasChildren(const void* self, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::hasChildren(*parent); + +} + +bool QPdfBookmarkModel_override_virtual_setData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setData = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::setData(*index, *value, static_cast(role)); + +} + +bool QPdfBookmarkModel_override_virtual_headerData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__headerData = slot; + return true; +} + +QVariant* QPdfBookmarkModel_virtualbase_headerData(const void* self, int section, int orientation, int role) { + + return new QVariant(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::headerData(static_cast(section), static_cast(orientation), static_cast(role))); + +} + +bool QPdfBookmarkModel_override_virtual_setHeaderData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setHeaderData = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::setHeaderData(static_cast(section), static_cast(orientation), *value, static_cast(role)); + +} + +bool QPdfBookmarkModel_override_virtual_itemData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__itemData = slot; + return true; +} + +struct miqt_map /* of int to QVariant* */ QPdfBookmarkModel_virtualbase_itemData(const void* self, QModelIndex* index) { + + QMap _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::itemData(*index); + // Convert QMap<> from C++ memory to manually-managed C memory + int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); + QVariant** _varr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + _karr[_ctr] = _itr->first; + _varr[_ctr] = new QVariant(_itr->second); + _ctr++; + } + struct miqt_map _out; + _out.len = _ret.size(); + _out.keys = static_cast(_karr); + _out.values = static_cast(_varr); + return _out; + +} + +bool QPdfBookmarkModel_override_virtual_setItemData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setItemData = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */ roles) { + QMap roles_QMap; + int* roles_karr = static_cast(roles.keys); + QVariant** roles_varr = static_cast(roles.values); + for(size_t i = 0; i < roles.len; ++i) { + roles_QMap[static_cast(roles_karr[i])] = *(roles_varr[i]); + } + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::setItemData(*index, roles_QMap); + +} + +bool QPdfBookmarkModel_override_virtual_mimeTypes(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mimeTypes = slot; + return true; +} + +struct miqt_array /* of struct miqt_string */ QPdfBookmarkModel_virtualbase_mimeTypes(const void* self) { + + QStringList _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::mimeTypes(); + // Convert QList<> from C++ memory to manually-managed C memory + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QString _lv_ret = _ret[i]; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _lv_b = _lv_ret.toUtf8(); + struct miqt_string _lv_ms; + _lv_ms.len = _lv_b.length(); + _lv_ms.data = static_cast(malloc(_lv_ms.len)); + memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len); + _arr[i] = _lv_ms; + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; + +} + +bool QPdfBookmarkModel_override_virtual_mimeData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mimeData = slot; + return true; +} + +QMimeData* QPdfBookmarkModel_virtualbase_mimeData(const void* 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])); + } + + return ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::mimeData(indexes_QList); + +} + +bool QPdfBookmarkModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__canDropMimeData = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::canDropMimeData(data, static_cast(action), static_cast(row), static_cast(column), *parent); + +} + +bool QPdfBookmarkModel_override_virtual_dropMimeData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__dropMimeData = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::dropMimeData(data, static_cast(action), static_cast(row), static_cast(column), *parent); + +} + +bool QPdfBookmarkModel_override_virtual_supportedDropActions(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__supportedDropActions = slot; + return true; +} + +int QPdfBookmarkModel_virtualbase_supportedDropActions(const void* self) { + + Qt::DropActions _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::supportedDropActions(); + return static_cast(_ret); + +} + +bool QPdfBookmarkModel_override_virtual_supportedDragActions(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__supportedDragActions = slot; + return true; +} + +int QPdfBookmarkModel_virtualbase_supportedDragActions(const void* self) { + + Qt::DropActions _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::supportedDragActions(); + return static_cast(_ret); + +} + +bool QPdfBookmarkModel_override_virtual_insertRows(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__insertRows = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::insertRows(static_cast(row), static_cast(count), *parent); + +} + +bool QPdfBookmarkModel_override_virtual_insertColumns(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__insertColumns = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::insertColumns(static_cast(column), static_cast(count), *parent); + +} + +bool QPdfBookmarkModel_override_virtual_removeRows(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__removeRows = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::removeRows(static_cast(row), static_cast(count), *parent); + +} + +bool QPdfBookmarkModel_override_virtual_removeColumns(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__removeColumns = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::removeColumns(static_cast(column), static_cast(count), *parent); + +} + +bool QPdfBookmarkModel_override_virtual_moveRows(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__moveRows = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::moveRows(*sourceParent, static_cast(sourceRow), static_cast(count), *destinationParent, static_cast(destinationChild)); + +} + +bool QPdfBookmarkModel_override_virtual_moveColumns(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__moveColumns = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::moveColumns(*sourceParent, static_cast(sourceColumn), static_cast(count), *destinationParent, static_cast(destinationChild)); + +} + +bool QPdfBookmarkModel_override_virtual_fetchMore(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__fetchMore = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_fetchMore(void* self, QModelIndex* parent) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::fetchMore(*parent); + +} + +bool QPdfBookmarkModel_override_virtual_canFetchMore(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__canFetchMore = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::canFetchMore(*parent); + +} + +bool QPdfBookmarkModel_override_virtual_flags(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__flags = slot; + return true; +} + +int QPdfBookmarkModel_virtualbase_flags(const void* self, QModelIndex* index) { + + Qt::ItemFlags _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::flags(*index); + return static_cast(_ret); + +} + +bool QPdfBookmarkModel_override_virtual_sort(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__sort = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_sort(void* self, int column, int order) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::sort(static_cast(column), static_cast(order)); + +} + +bool QPdfBookmarkModel_override_virtual_buddy(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__buddy = slot; + return true; +} + +QModelIndex* QPdfBookmarkModel_virtualbase_buddy(const void* self, QModelIndex* index) { + + return new QModelIndex(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::buddy(*index)); + +} + +bool QPdfBookmarkModel_override_virtual_match(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__match = slot; + return true; +} + +struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { + + QModelIndexList _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + // 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; + +} + +bool QPdfBookmarkModel_override_virtual_span(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__span = slot; + return true; +} + +QSize* QPdfBookmarkModel_virtualbase_span(const void* self, QModelIndex* index) { + + return new QSize(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::span(*index)); + +} + +bool QPdfBookmarkModel_override_virtual_submit(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__submit = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_submit(void* self) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::submit(); + +} + +bool QPdfBookmarkModel_override_virtual_revert(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__revert = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_revert(void* self) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::revert(); + +} + +bool QPdfBookmarkModel_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_event(void* self, QEvent* event) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::event(event); + +} + +bool QPdfBookmarkModel_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::eventFilter(watched, event); + +} + +bool QPdfBookmarkModel_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_timerEvent(void* self, QTimerEvent* event) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::timerEvent(event); + +} + +bool QPdfBookmarkModel_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_childEvent(void* self, QChildEvent* event) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::childEvent(event); + +} + +bool QPdfBookmarkModel_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_customEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::customEvent(event); + +} + +bool QPdfBookmarkModel_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::connectNotify(*signal); + +} + +bool QPdfBookmarkModel_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::disconnectNotify(*signal); + +} + +void QPdfBookmarkModel_protectedbase_resetInternalData(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->resetInternalData(); + +} + +QModelIndex* QPdfBookmarkModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return new QModelIndex(self_cast->createIndex(static_cast(row), static_cast(column))); + +} + +void QPdfBookmarkModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */ indexes, QDataStream* stream) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + 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_cast->encodeData(indexes_QList, *stream); + +} + +bool QPdfBookmarkModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->decodeData(static_cast(row), static_cast(column), *parent, *stream); + +} + +void QPdfBookmarkModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginInsertRows(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfBookmarkModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endInsertRows(); + +} + +void QPdfBookmarkModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginRemoveRows(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfBookmarkModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endRemoveRows(); + +} + +bool QPdfBookmarkModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->beginMoveRows(*sourceParent, static_cast(sourceFirst), static_cast(sourceLast), *destinationParent, static_cast(destinationRow)); + +} + +void QPdfBookmarkModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endMoveRows(); + +} + +void QPdfBookmarkModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginInsertColumns(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfBookmarkModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endInsertColumns(); + +} + +void QPdfBookmarkModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginRemoveColumns(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfBookmarkModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endRemoveColumns(); + +} + +bool QPdfBookmarkModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->beginMoveColumns(*sourceParent, static_cast(sourceFirst), static_cast(sourceLast), *destinationParent, static_cast(destinationColumn)); + +} + +void QPdfBookmarkModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endMoveColumns(); + +} + +void QPdfBookmarkModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginResetModel(); + +} + +void QPdfBookmarkModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endResetModel(); + +} + +void QPdfBookmarkModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->changePersistentIndex(*from, *to); + +} + +void QPdfBookmarkModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */ from, struct miqt_array /* of QModelIndex* */ to) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + QModelIndexList from_QList; + from_QList.reserve(from.len); + QModelIndex** from_arr = static_cast(from.data); + for(size_t i = 0; i < from.len; ++i) { + from_QList.push_back(*(from_arr[i])); + } + QModelIndexList to_QList; + to_QList.reserve(to.len); + QModelIndex** to_arr = static_cast(to.data); + for(size_t i = 0; i < to.len; ++i) { + to_QList.push_back(*(to_arr[i])); + } + + self_cast->changePersistentIndexList(from_QList, to_QList); + +} + +struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return (struct miqt_array){}; + } + + *_dynamic_cast_ok = true; + + QModelIndexList _ret = self_cast->persistentIndexList(); + // 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; + +} + +QObject* QPdfBookmarkModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return self_cast->sender(); + +} + +int QPdfBookmarkModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->senderSignalIndex(); + +} + +int QPdfBookmarkModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->receivers(signal); + +} + +bool QPdfBookmarkModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->isSignalConnected(*signal); + +} + +void QPdfBookmarkModel_delete(QPdfBookmarkModel* self) { + delete self; +} + diff --git a/qt/pdf/gen_qpdfbookmarkmodel.go b/qt/pdf/gen_qpdfbookmarkmodel.go new file mode 100644 index 00000000..23e1a658 --- /dev/null +++ b/qt/pdf/gen_qpdfbookmarkmodel.go @@ -0,0 +1,1964 @@ +package pdf + +/* + +#include "gen_qpdfbookmarkmodel.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QPdfBookmarkModel__StructureMode int + +const ( + QPdfBookmarkModel__TreeMode QPdfBookmarkModel__StructureMode = 0 + QPdfBookmarkModel__ListMode QPdfBookmarkModel__StructureMode = 1 +) + +type QPdfBookmarkModel__Role int + +const ( + QPdfBookmarkModel__TitleRole QPdfBookmarkModel__Role = 0 + QPdfBookmarkModel__LevelRole QPdfBookmarkModel__Role = 256 + QPdfBookmarkModel__PageNumberRole QPdfBookmarkModel__Role = 257 +) + +type QPdfBookmarkModel struct { + h *C.QPdfBookmarkModel + *qt.QAbstractItemModel +} + +func (this *QPdfBookmarkModel) cPointer() *C.QPdfBookmarkModel { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfBookmarkModel) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfBookmarkModel constructs the type using only CGO pointers. +func newQPdfBookmarkModel(h *C.QPdfBookmarkModel) *QPdfBookmarkModel { + if h == nil { + return nil + } + var outptr_QAbstractItemModel *C.QAbstractItemModel = nil + C.QPdfBookmarkModel_virtbase(h, &outptr_QAbstractItemModel) + + return &QPdfBookmarkModel{h: h, + QAbstractItemModel: qt.UnsafeNewQAbstractItemModel(unsafe.Pointer(outptr_QAbstractItemModel))} +} + +// UnsafeNewQPdfBookmarkModel constructs the type using only unsafe pointers. +func UnsafeNewQPdfBookmarkModel(h unsafe.Pointer) *QPdfBookmarkModel { + return newQPdfBookmarkModel((*C.QPdfBookmarkModel)(h)) +} + +// NewQPdfBookmarkModel constructs a new QPdfBookmarkModel object. +func NewQPdfBookmarkModel() *QPdfBookmarkModel { + + return newQPdfBookmarkModel(C.QPdfBookmarkModel_new()) +} + +// NewQPdfBookmarkModel2 constructs a new QPdfBookmarkModel object. +func NewQPdfBookmarkModel2(parent *qt.QObject) *QPdfBookmarkModel { + + return newQPdfBookmarkModel(C.QPdfBookmarkModel_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QPdfBookmarkModel) MetaObject() *qt.QMetaObject { + return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QPdfBookmarkModel_metaObject(this.h))) +} + +func (this *QPdfBookmarkModel) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QPdfBookmarkModel_metacast(this.h, param1_Cstring)) +} + +func QPdfBookmarkModel_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfBookmarkModel_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfBookmarkModel_TrUtf8(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfBookmarkModel_trUtf8(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfBookmarkModel) Document() *QPdfDocument { + return newQPdfDocument(C.QPdfBookmarkModel_document(this.h)) +} + +func (this *QPdfBookmarkModel) SetDocument(document *QPdfDocument) { + C.QPdfBookmarkModel_setDocument(this.h, document.cPointer()) +} + +func (this *QPdfBookmarkModel) StructureMode() QPdfBookmarkModel__StructureMode { + return (QPdfBookmarkModel__StructureMode)(C.QPdfBookmarkModel_structureMode(this.h)) +} + +func (this *QPdfBookmarkModel) SetStructureMode(mode QPdfBookmarkModel__StructureMode) { + C.QPdfBookmarkModel_setStructureMode(this.h, (C.int)(mode)) +} + +func (this *QPdfBookmarkModel) Data(index *qt.QModelIndex, role int) *qt.QVariant { + _goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QPdfBookmarkModel_data(this.h, (*C.QModelIndex)(index.UnsafePointer()), (C.int)(role)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfBookmarkModel) Index(row int, column int, parent *qt.QModelIndex) *qt.QModelIndex { + _goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_index(this.h, (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfBookmarkModel) Parent(index *qt.QModelIndex) *qt.QModelIndex { + _goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_parent(this.h, (*C.QModelIndex)(index.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfBookmarkModel) RowCount(parent *qt.QModelIndex) int { + return (int)(C.QPdfBookmarkModel_rowCount(this.h, (*C.QModelIndex)(parent.UnsafePointer()))) +} + +func (this *QPdfBookmarkModel) ColumnCount(parent *qt.QModelIndex) int { + return (int)(C.QPdfBookmarkModel_columnCount(this.h, (*C.QModelIndex)(parent.UnsafePointer()))) +} + +func (this *QPdfBookmarkModel) RoleNames() map[int][]byte { + var _mm C.struct_miqt_map = C.QPdfBookmarkModel_roleNames(this.h) + _ret := make(map[int][]byte, int(_mm.len)) + _Keys := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + _entry_Key := (int)(_Keys[i]) + + var _hashval_bytearray C.struct_miqt_string = _Values[i] + _hashval_ret := C.GoBytes(unsafe.Pointer(_hashval_bytearray.data), C.int(int64(_hashval_bytearray.len))) + C.free(unsafe.Pointer(_hashval_bytearray.data)) + _entry_Value := _hashval_ret + _ret[_entry_Key] = _entry_Value + } + return _ret +} + +func (this *QPdfBookmarkModel) DocumentChanged(document *QPdfDocument) { + C.QPdfBookmarkModel_documentChanged(this.h, document.cPointer()) +} +func (this *QPdfBookmarkModel) OnDocumentChanged(slot func(document *QPdfDocument)) { + C.QPdfBookmarkModel_connect_documentChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfBookmarkModel_documentChanged +func miqt_exec_callback_QPdfBookmarkModel_documentChanged(cb C.intptr_t, document *C.QPdfDocument) { + gofunc, ok := cgo.Handle(cb).Value().(func(document *QPdfDocument)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQPdfDocument(document) + + gofunc(slotval1) +} + +func (this *QPdfBookmarkModel) StructureModeChanged(structureMode QPdfBookmarkModel__StructureMode) { + C.QPdfBookmarkModel_structureModeChanged(this.h, (C.int)(structureMode)) +} +func (this *QPdfBookmarkModel) OnStructureModeChanged(slot func(structureMode QPdfBookmarkModel__StructureMode)) { + C.QPdfBookmarkModel_connect_structureModeChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfBookmarkModel_structureModeChanged +func miqt_exec_callback_QPdfBookmarkModel_structureModeChanged(cb C.intptr_t, structureMode C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(structureMode QPdfBookmarkModel__StructureMode)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (QPdfBookmarkModel__StructureMode)(structureMode) + + gofunc(slotval1) +} + +func QPdfBookmarkModel_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfBookmarkModel_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfBookmarkModel_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfBookmarkModel_tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfBookmarkModel_TrUtf82(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfBookmarkModel_trUtf82(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfBookmarkModel_TrUtf83(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfBookmarkModel_trUtf83(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +// ResetInternalData can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) ResetInternalData() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_resetInternalData(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// CreateIndex can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) CreateIndex(row int, column int) qt.QModelIndex { + + var _dynamic_cast_ok C.bool = false + _goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_protectedbase_createIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h), (C.int)(row), (C.int)(column)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _method_ret := *_goptr + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// EncodeData can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EncodeData(indexes []qt.QModelIndex, stream *qt.QDataStream) { + indexes_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(indexes)))) + defer C.free(unsafe.Pointer(indexes_CArray)) + for i := range indexes { + indexes_CArray[i] = (*C.QModelIndex)(indexes[i].UnsafePointer()) + } + indexes_ma := C.struct_miqt_array{len: C.size_t(len(indexes)), data: unsafe.Pointer(indexes_CArray)} + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_encodeData(&_dynamic_cast_ok, unsafe.Pointer(this.h), indexes_ma, (*C.QDataStream)(stream.UnsafePointer())) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// DecodeData can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) DecodeData(row int, column int, parent *qt.QModelIndex, stream *qt.QDataStream) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfBookmarkModel_protectedbase_decodeData(&_dynamic_cast_ok, unsafe.Pointer(this.h), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer()), (*C.QDataStream)(stream.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// BeginInsertRows can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginInsertRows(parent *qt.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_beginInsertRows(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndInsertRows can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndInsertRows() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endInsertRows(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginRemoveRows can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginRemoveRows(parent *qt.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_beginRemoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndRemoveRows can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndRemoveRows() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endRemoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginMoveRows can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginMoveRows(sourceParent *qt.QModelIndex, sourceFirst int, sourceLast int, destinationParent *qt.QModelIndex, destinationRow int) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfBookmarkModel_protectedbase_beginMoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceFirst), (C.int)(sourceLast), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationRow))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// EndMoveRows can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndMoveRows() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endMoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginInsertColumns can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginInsertColumns(parent *qt.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_beginInsertColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndInsertColumns can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndInsertColumns() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endInsertColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginRemoveColumns can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginRemoveColumns(parent *qt.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_beginRemoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndRemoveColumns can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndRemoveColumns() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endRemoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginMoveColumns can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginMoveColumns(sourceParent *qt.QModelIndex, sourceFirst int, sourceLast int, destinationParent *qt.QModelIndex, destinationColumn int) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfBookmarkModel_protectedbase_beginMoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceFirst), (C.int)(sourceLast), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationColumn))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// EndMoveColumns can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndMoveColumns() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endMoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginResetModel can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginResetModel() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_beginResetModel(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndResetModel can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndResetModel() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endResetModel(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// ChangePersistentIndex can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) ChangePersistentIndex(from *qt.QModelIndex, to *qt.QModelIndex) { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_changePersistentIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(from.UnsafePointer()), (*C.QModelIndex)(to.UnsafePointer())) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// ChangePersistentIndexList can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) ChangePersistentIndexList(from []qt.QModelIndex, to []qt.QModelIndex) { + from_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(from)))) + defer C.free(unsafe.Pointer(from_CArray)) + for i := range from { + from_CArray[i] = (*C.QModelIndex)(from[i].UnsafePointer()) + } + from_ma := C.struct_miqt_array{len: C.size_t(len(from)), data: unsafe.Pointer(from_CArray)} + to_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(to)))) + defer C.free(unsafe.Pointer(to_CArray)) + for i := range to { + to_CArray[i] = (*C.QModelIndex)(to[i].UnsafePointer()) + } + to_ma := C.struct_miqt_array{len: C.size_t(len(to)), data: unsafe.Pointer(to_CArray)} + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_changePersistentIndexList(&_dynamic_cast_ok, unsafe.Pointer(this.h), from_ma, to_ma) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// PersistentIndexList can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) PersistentIndexList() []qt.QModelIndex { + + var _dynamic_cast_ok C.bool = false + var _ma C.struct_miqt_array = C.QPdfBookmarkModel_protectedbase_persistentIndexList(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + _ret := make([]qt.QModelIndex, int(_ma.len)) + _outCast := (*[0xffff]*C.QModelIndex)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(_outCast[i])) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + _method_ret := _ret + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Sender can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) Sender() *qt.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt.UnsafeNewQObject(unsafe.Pointer(C.QPdfBookmarkModel_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// SenderSignalIndex can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfBookmarkModel_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Receivers can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) Receivers(signal string) int { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfBookmarkModel_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// IsSignalConnected can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) IsSignalConnected(signal *qt.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfBookmarkModel_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Data(index *qt.QModelIndex, role int) *qt.QVariant { + + _goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_data(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), (C.int)(role)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnData(slot func(super func(index *qt.QModelIndex, role int) *qt.QVariant, index *qt.QModelIndex, role int) *qt.QVariant) { + ok := C.QPdfBookmarkModel_override_virtual_data(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_data +func miqt_exec_callback_QPdfBookmarkModel_data(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex, role C.int) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex, role int) *qt.QVariant, index *qt.QModelIndex, role int) *qt.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + slotval2 := (int)(role) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Data, slotval1, slotval2) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Index(row int, column int, parent *qt.QModelIndex) *qt.QModelIndex { + + _goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_index(unsafe.Pointer(this.h), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnIndex(slot func(super func(row int, column int, parent *qt.QModelIndex) *qt.QModelIndex, row int, column int, parent *qt.QModelIndex) *qt.QModelIndex) { + ok := C.QPdfBookmarkModel_override_virtual_index(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_index +func miqt_exec_callback_QPdfBookmarkModel_index(self *C.QPdfBookmarkModel, cb C.intptr_t, row C.int, column C.int, parent *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, column int, parent *qt.QModelIndex) *qt.QModelIndex, row int, column int, parent *qt.QModelIndex) *qt.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(column) + + slotval3 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Index, slotval1, slotval2, slotval3) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Parent(index *qt.QModelIndex) *qt.QModelIndex { + + _goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_parent(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnParent(slot func(super func(index *qt.QModelIndex) *qt.QModelIndex, index *qt.QModelIndex) *qt.QModelIndex) { + ok := C.QPdfBookmarkModel_override_virtual_parent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_parent +func miqt_exec_callback_QPdfBookmarkModel_parent(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex) *qt.QModelIndex, index *qt.QModelIndex) *qt.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Parent, slotval1) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_RowCount(parent *qt.QModelIndex) int { + + return (int)(C.QPdfBookmarkModel_virtualbase_rowCount(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnRowCount(slot func(super func(parent *qt.QModelIndex) int, parent *qt.QModelIndex) int) { + ok := C.QPdfBookmarkModel_override_virtual_rowCount(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_rowCount +func miqt_exec_callback_QPdfBookmarkModel_rowCount(self *C.QPdfBookmarkModel, cb C.intptr_t, parent *C.QModelIndex) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt.QModelIndex) int, parent *qt.QModelIndex) int) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_RowCount, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_ColumnCount(parent *qt.QModelIndex) int { + + return (int)(C.QPdfBookmarkModel_virtualbase_columnCount(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnColumnCount(slot func(super func(parent *qt.QModelIndex) int, parent *qt.QModelIndex) int) { + ok := C.QPdfBookmarkModel_override_virtual_columnCount(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_columnCount +func miqt_exec_callback_QPdfBookmarkModel_columnCount(self *C.QPdfBookmarkModel, cb C.intptr_t, parent *C.QModelIndex) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt.QModelIndex) int, parent *qt.QModelIndex) int) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_ColumnCount, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_RoleNames() map[int][]byte { + + var _mm C.struct_miqt_map = C.QPdfBookmarkModel_virtualbase_roleNames(unsafe.Pointer(this.h)) + _ret := make(map[int][]byte, int(_mm.len)) + _Keys := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + _entry_Key := (int)(_Keys[i]) + + var _hashval_bytearray C.struct_miqt_string = _Values[i] + _hashval_ret := C.GoBytes(unsafe.Pointer(_hashval_bytearray.data), C.int(int64(_hashval_bytearray.len))) + C.free(unsafe.Pointer(_hashval_bytearray.data)) + _entry_Value := _hashval_ret + _ret[_entry_Key] = _entry_Value + } + return _ret + +} +func (this *QPdfBookmarkModel) OnRoleNames(slot func(super func() map[int][]byte) map[int][]byte) { + ok := C.QPdfBookmarkModel_override_virtual_roleNames(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_roleNames +func miqt_exec_callback_QPdfBookmarkModel_roleNames(self *C.QPdfBookmarkModel, cb C.intptr_t) C.struct_miqt_map { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() map[int][]byte) map[int][]byte) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_RoleNames) + virtualReturn_Keys_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Keys_CArray)) + virtualReturn_Values_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Values_CArray)) + virtualReturn_ctr := 0 + for virtualReturn_k, virtualReturn_v := range virtualReturn { + virtualReturn_Keys_CArray[virtualReturn_ctr] = (C.int)(virtualReturn_k) + virtualReturn_v_alias := C.struct_miqt_string{} + if len(virtualReturn_v) > 0 { + virtualReturn_v_alias.data = (*C.char)(unsafe.Pointer(&virtualReturn_v[0])) + } else { + virtualReturn_v_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + virtualReturn_v_alias.len = C.size_t(len(virtualReturn_v)) + virtualReturn_Values_CArray[virtualReturn_ctr] = virtualReturn_v_alias + virtualReturn_ctr++ + } + virtualReturn_mm := C.struct_miqt_map{ + len: C.size_t(len(virtualReturn)), + keys: unsafe.Pointer(virtualReturn_Keys_CArray), + values: unsafe.Pointer(virtualReturn_Values_CArray), + } + + return virtualReturn_mm + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Sibling(row int, column int, idx *qt.QModelIndex) *qt.QModelIndex { + + _goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_sibling(unsafe.Pointer(this.h), (C.int)(row), (C.int)(column), (*C.QModelIndex)(idx.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnSibling(slot func(super func(row int, column int, idx *qt.QModelIndex) *qt.QModelIndex, row int, column int, idx *qt.QModelIndex) *qt.QModelIndex) { + ok := C.QPdfBookmarkModel_override_virtual_sibling(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_sibling +func miqt_exec_callback_QPdfBookmarkModel_sibling(self *C.QPdfBookmarkModel, cb C.intptr_t, row C.int, column C.int, idx *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, column int, idx *qt.QModelIndex) *qt.QModelIndex, row int, column int, idx *qt.QModelIndex) *qt.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(column) + + slotval3 := qt.UnsafeNewQModelIndex(unsafe.Pointer(idx)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Sibling, slotval1, slotval2, slotval3) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_HasChildren(parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_hasChildren(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnHasChildren(slot func(super func(parent *qt.QModelIndex) bool, parent *qt.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_hasChildren(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_hasChildren +func miqt_exec_callback_QPdfBookmarkModel_hasChildren(self *C.QPdfBookmarkModel, cb C.intptr_t, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt.QModelIndex) bool, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_HasChildren, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_SetData(index *qt.QModelIndex, value *qt.QVariant, role int) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_setData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), (*C.QVariant)(value.UnsafePointer()), (C.int)(role))) + +} +func (this *QPdfBookmarkModel) OnSetData(slot func(super func(index *qt.QModelIndex, value *qt.QVariant, role int) bool, index *qt.QModelIndex, value *qt.QVariant, role int) bool) { + ok := C.QPdfBookmarkModel_override_virtual_setData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_setData +func miqt_exec_callback_QPdfBookmarkModel_setData(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex, value *C.QVariant, role C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex, value *qt.QVariant, role int) bool, index *qt.QModelIndex, value *qt.QVariant, role int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + slotval2 := qt.UnsafeNewQVariant(unsafe.Pointer(value)) + + slotval3 := (int)(role) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_SetData, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_HeaderData(section int, orientation qt.Orientation, role int) *qt.QVariant { + + _goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_headerData(unsafe.Pointer(this.h), (C.int)(section), (C.int)(orientation), (C.int)(role)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnHeaderData(slot func(super func(section int, orientation qt.Orientation, role int) *qt.QVariant, section int, orientation qt.Orientation, role int) *qt.QVariant) { + ok := C.QPdfBookmarkModel_override_virtual_headerData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_headerData +func miqt_exec_callback_QPdfBookmarkModel_headerData(self *C.QPdfBookmarkModel, cb C.intptr_t, section C.int, orientation C.int, role C.int) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(section int, orientation qt.Orientation, role int) *qt.QVariant, section int, orientation qt.Orientation, role int) *qt.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(section) + + slotval2 := (qt.Orientation)(orientation) + + slotval3 := (int)(role) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_HeaderData, slotval1, slotval2, slotval3) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_SetHeaderData(section int, orientation qt.Orientation, value *qt.QVariant, role int) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_setHeaderData(unsafe.Pointer(this.h), (C.int)(section), (C.int)(orientation), (*C.QVariant)(value.UnsafePointer()), (C.int)(role))) + +} +func (this *QPdfBookmarkModel) OnSetHeaderData(slot func(super func(section int, orientation qt.Orientation, value *qt.QVariant, role int) bool, section int, orientation qt.Orientation, value *qt.QVariant, role int) bool) { + ok := C.QPdfBookmarkModel_override_virtual_setHeaderData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_setHeaderData +func miqt_exec_callback_QPdfBookmarkModel_setHeaderData(self *C.QPdfBookmarkModel, cb C.intptr_t, section C.int, orientation C.int, value *C.QVariant, role C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(section int, orientation qt.Orientation, value *qt.QVariant, role int) bool, section int, orientation qt.Orientation, value *qt.QVariant, role int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(section) + + slotval2 := (qt.Orientation)(orientation) + + slotval3 := qt.UnsafeNewQVariant(unsafe.Pointer(value)) + + slotval4 := (int)(role) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_SetHeaderData, slotval1, slotval2, slotval3, slotval4) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_ItemData(index *qt.QModelIndex) map[int]qt.QVariant { + + var _mm C.struct_miqt_map = C.QPdfBookmarkModel_virtualbase_itemData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())) + _ret := make(map[int]qt.QVariant, int(_mm.len)) + _Keys := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + _entry_Key := (int)(_Keys[i]) + + _mapval_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(_Values[i])) + _mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _entry_Value := *_mapval_goptr + + _ret[_entry_Key] = _entry_Value + } + return _ret + +} +func (this *QPdfBookmarkModel) OnItemData(slot func(super func(index *qt.QModelIndex) map[int]qt.QVariant, index *qt.QModelIndex) map[int]qt.QVariant) { + ok := C.QPdfBookmarkModel_override_virtual_itemData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_itemData +func miqt_exec_callback_QPdfBookmarkModel_itemData(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex) C.struct_miqt_map { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex) map[int]qt.QVariant, index *qt.QModelIndex) map[int]qt.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_ItemData, slotval1) + virtualReturn_Keys_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Keys_CArray)) + virtualReturn_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Values_CArray)) + virtualReturn_ctr := 0 + for virtualReturn_k, virtualReturn_v := range virtualReturn { + virtualReturn_Keys_CArray[virtualReturn_ctr] = (C.int)(virtualReturn_k) + virtualReturn_Values_CArray[virtualReturn_ctr] = (*C.QVariant)(virtualReturn_v.UnsafePointer()) + virtualReturn_ctr++ + } + virtualReturn_mm := C.struct_miqt_map{ + len: C.size_t(len(virtualReturn)), + keys: unsafe.Pointer(virtualReturn_Keys_CArray), + values: unsafe.Pointer(virtualReturn_Values_CArray), + } + + return virtualReturn_mm + +} + +func (this *QPdfBookmarkModel) callVirtualBase_SetItemData(index *qt.QModelIndex, roles map[int]qt.QVariant) bool { + roles_Keys_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(roles)))) + defer C.free(unsafe.Pointer(roles_Keys_CArray)) + roles_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(roles)))) + defer C.free(unsafe.Pointer(roles_Values_CArray)) + roles_ctr := 0 + for roles_k, roles_v := range roles { + roles_Keys_CArray[roles_ctr] = (C.int)(roles_k) + roles_Values_CArray[roles_ctr] = (*C.QVariant)(roles_v.UnsafePointer()) + roles_ctr++ + } + roles_mm := C.struct_miqt_map{ + len: C.size_t(len(roles)), + keys: unsafe.Pointer(roles_Keys_CArray), + values: unsafe.Pointer(roles_Values_CArray), + } + + return (bool)(C.QPdfBookmarkModel_virtualbase_setItemData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), roles_mm)) + +} +func (this *QPdfBookmarkModel) OnSetItemData(slot func(super func(index *qt.QModelIndex, roles map[int]qt.QVariant) bool, index *qt.QModelIndex, roles map[int]qt.QVariant) bool) { + ok := C.QPdfBookmarkModel_override_virtual_setItemData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_setItemData +func miqt_exec_callback_QPdfBookmarkModel_setItemData(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex, roles C.struct_miqt_map) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex, roles map[int]qt.QVariant) bool, index *qt.QModelIndex, roles map[int]qt.QVariant) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + var roles_mm C.struct_miqt_map = roles + roles_ret := make(map[int]qt.QVariant, int(roles_mm.len)) + roles_Keys := (*[0xffff]C.int)(unsafe.Pointer(roles_mm.keys)) + roles_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(roles_mm.values)) + for i := 0; i < int(roles_mm.len); i++ { + roles_entry_Key := (int)(roles_Keys[i]) + + roles_mapval_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(roles_Values[i])) + roles_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + roles_entry_Value := *roles_mapval_goptr + + roles_ret[roles_entry_Key] = roles_entry_Value + } + slotval2 := roles_ret + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_SetItemData, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_MimeTypes() []string { + + var _ma C.struct_miqt_array = C.QPdfBookmarkModel_virtualbase_mimeTypes(unsafe.Pointer(this.h)) + _ret := make([]string, int(_ma.len)) + _outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + var _lv_ms C.struct_miqt_string = _outCast[i] + _lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len))) + C.free(unsafe.Pointer(_lv_ms.data)) + _ret[i] = _lv_ret + } + return _ret + +} +func (this *QPdfBookmarkModel) OnMimeTypes(slot func(super func() []string) []string) { + ok := C.QPdfBookmarkModel_override_virtual_mimeTypes(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_mimeTypes +func miqt_exec_callback_QPdfBookmarkModel_mimeTypes(self *C.QPdfBookmarkModel, cb C.intptr_t) C.struct_miqt_array { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() []string) []string) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_MimeTypes) + virtualReturn_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_CArray)) + for i := range virtualReturn { + virtualReturn_i_ms := C.struct_miqt_string{} + virtualReturn_i_ms.data = C.CString(virtualReturn[i]) + virtualReturn_i_ms.len = C.size_t(len(virtualReturn[i])) + defer C.free(unsafe.Pointer(virtualReturn_i_ms.data)) + virtualReturn_CArray[i] = virtualReturn_i_ms + } + virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)} + + return virtualReturn_ma + +} + +func (this *QPdfBookmarkModel) callVirtualBase_MimeData(indexes []qt.QModelIndex) *qt.QMimeData { + indexes_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(indexes)))) + defer C.free(unsafe.Pointer(indexes_CArray)) + for i := range indexes { + indexes_CArray[i] = (*C.QModelIndex)(indexes[i].UnsafePointer()) + } + indexes_ma := C.struct_miqt_array{len: C.size_t(len(indexes)), data: unsafe.Pointer(indexes_CArray)} + + return qt.UnsafeNewQMimeData(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_mimeData(unsafe.Pointer(this.h), indexes_ma))) + +} +func (this *QPdfBookmarkModel) OnMimeData(slot func(super func(indexes []qt.QModelIndex) *qt.QMimeData, indexes []qt.QModelIndex) *qt.QMimeData) { + ok := C.QPdfBookmarkModel_override_virtual_mimeData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_mimeData +func miqt_exec_callback_QPdfBookmarkModel_mimeData(self *C.QPdfBookmarkModel, cb C.intptr_t, indexes C.struct_miqt_array) *C.QMimeData { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(indexes []qt.QModelIndex) *qt.QMimeData, indexes []qt.QModelIndex) *qt.QMimeData) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var indexes_ma C.struct_miqt_array = indexes + indexes_ret := make([]qt.QModelIndex, int(indexes_ma.len)) + indexes_outCast := (*[0xffff]*C.QModelIndex)(unsafe.Pointer(indexes_ma.data)) // hey ya + for i := 0; i < int(indexes_ma.len); i++ { + indexes_lv_goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(indexes_outCast[i])) + indexes_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + indexes_ret[i] = *indexes_lv_goptr + } + slotval1 := indexes_ret + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_MimeData, slotval1) + + return (*C.QMimeData)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_CanDropMimeData(data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_canDropMimeData(unsafe.Pointer(this.h), (*C.QMimeData)(data.UnsafePointer()), (C.int)(action), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnCanDropMimeData(slot func(super func(data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool, data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_canDropMimeData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_canDropMimeData +func miqt_exec_callback_QPdfBookmarkModel_canDropMimeData(self *C.QPdfBookmarkModel, cb C.intptr_t, data *C.QMimeData, action C.int, row C.int, column C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool, data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMimeData(unsafe.Pointer(data)) + + slotval2 := (qt.DropAction)(action) + + slotval3 := (int)(row) + + slotval4 := (int)(column) + + slotval5 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_CanDropMimeData, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_DropMimeData(data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_dropMimeData(unsafe.Pointer(this.h), (*C.QMimeData)(data.UnsafePointer()), (C.int)(action), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnDropMimeData(slot func(super func(data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool, data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_dropMimeData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_dropMimeData +func miqt_exec_callback_QPdfBookmarkModel_dropMimeData(self *C.QPdfBookmarkModel, cb C.intptr_t, data *C.QMimeData, action C.int, row C.int, column C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool, data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMimeData(unsafe.Pointer(data)) + + slotval2 := (qt.DropAction)(action) + + slotval3 := (int)(row) + + slotval4 := (int)(column) + + slotval5 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_DropMimeData, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_SupportedDropActions() qt.DropAction { + + return (qt.DropAction)(C.QPdfBookmarkModel_virtualbase_supportedDropActions(unsafe.Pointer(this.h))) + +} +func (this *QPdfBookmarkModel) OnSupportedDropActions(slot func(super func() qt.DropAction) qt.DropAction) { + ok := C.QPdfBookmarkModel_override_virtual_supportedDropActions(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_supportedDropActions +func miqt_exec_callback_QPdfBookmarkModel_supportedDropActions(self *C.QPdfBookmarkModel, cb C.intptr_t) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() qt.DropAction) qt.DropAction) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_SupportedDropActions) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_SupportedDragActions() qt.DropAction { + + return (qt.DropAction)(C.QPdfBookmarkModel_virtualbase_supportedDragActions(unsafe.Pointer(this.h))) + +} +func (this *QPdfBookmarkModel) OnSupportedDragActions(slot func(super func() qt.DropAction) qt.DropAction) { + ok := C.QPdfBookmarkModel_override_virtual_supportedDragActions(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_supportedDragActions +func miqt_exec_callback_QPdfBookmarkModel_supportedDragActions(self *C.QPdfBookmarkModel, cb C.intptr_t) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() qt.DropAction) qt.DropAction) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_SupportedDragActions) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_InsertRows(row int, count int, parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_insertRows(unsafe.Pointer(this.h), (C.int)(row), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnInsertRows(slot func(super func(row int, count int, parent *qt.QModelIndex) bool, row int, count int, parent *qt.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_insertRows(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_insertRows +func miqt_exec_callback_QPdfBookmarkModel_insertRows(self *C.QPdfBookmarkModel, cb C.intptr_t, row C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, count int, parent *qt.QModelIndex) bool, row int, count int, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(count) + + slotval3 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_InsertRows, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_InsertColumns(column int, count int, parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_insertColumns(unsafe.Pointer(this.h), (C.int)(column), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnInsertColumns(slot func(super func(column int, count int, parent *qt.QModelIndex) bool, column int, count int, parent *qt.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_insertColumns(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_insertColumns +func miqt_exec_callback_QPdfBookmarkModel_insertColumns(self *C.QPdfBookmarkModel, cb C.intptr_t, column C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(column int, count int, parent *qt.QModelIndex) bool, column int, count int, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(column) + + slotval2 := (int)(count) + + slotval3 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_InsertColumns, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_RemoveRows(row int, count int, parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_removeRows(unsafe.Pointer(this.h), (C.int)(row), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnRemoveRows(slot func(super func(row int, count int, parent *qt.QModelIndex) bool, row int, count int, parent *qt.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_removeRows(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_removeRows +func miqt_exec_callback_QPdfBookmarkModel_removeRows(self *C.QPdfBookmarkModel, cb C.intptr_t, row C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, count int, parent *qt.QModelIndex) bool, row int, count int, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(count) + + slotval3 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_RemoveRows, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_RemoveColumns(column int, count int, parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_removeColumns(unsafe.Pointer(this.h), (C.int)(column), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnRemoveColumns(slot func(super func(column int, count int, parent *qt.QModelIndex) bool, column int, count int, parent *qt.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_removeColumns(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_removeColumns +func miqt_exec_callback_QPdfBookmarkModel_removeColumns(self *C.QPdfBookmarkModel, cb C.intptr_t, column C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(column int, count int, parent *qt.QModelIndex) bool, column int, count int, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(column) + + slotval2 := (int)(count) + + slotval3 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_RemoveColumns, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_MoveRows(sourceParent *qt.QModelIndex, sourceRow int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_moveRows(unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceRow), (C.int)(count), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationChild))) + +} +func (this *QPdfBookmarkModel) OnMoveRows(slot func(super func(sourceParent *qt.QModelIndex, sourceRow int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool, sourceParent *qt.QModelIndex, sourceRow int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool) { + ok := C.QPdfBookmarkModel_override_virtual_moveRows(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_moveRows +func miqt_exec_callback_QPdfBookmarkModel_moveRows(self *C.QPdfBookmarkModel, cb C.intptr_t, sourceParent *C.QModelIndex, sourceRow C.int, count C.int, destinationParent *C.QModelIndex, destinationChild C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(sourceParent *qt.QModelIndex, sourceRow int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool, sourceParent *qt.QModelIndex, sourceRow int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(sourceParent)) + + slotval2 := (int)(sourceRow) + + slotval3 := (int)(count) + + slotval4 := qt.UnsafeNewQModelIndex(unsafe.Pointer(destinationParent)) + + slotval5 := (int)(destinationChild) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_MoveRows, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_MoveColumns(sourceParent *qt.QModelIndex, sourceColumn int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_moveColumns(unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceColumn), (C.int)(count), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationChild))) + +} +func (this *QPdfBookmarkModel) OnMoveColumns(slot func(super func(sourceParent *qt.QModelIndex, sourceColumn int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool, sourceParent *qt.QModelIndex, sourceColumn int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool) { + ok := C.QPdfBookmarkModel_override_virtual_moveColumns(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_moveColumns +func miqt_exec_callback_QPdfBookmarkModel_moveColumns(self *C.QPdfBookmarkModel, cb C.intptr_t, sourceParent *C.QModelIndex, sourceColumn C.int, count C.int, destinationParent *C.QModelIndex, destinationChild C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(sourceParent *qt.QModelIndex, sourceColumn int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool, sourceParent *qt.QModelIndex, sourceColumn int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(sourceParent)) + + slotval2 := (int)(sourceColumn) + + slotval3 := (int)(count) + + slotval4 := qt.UnsafeNewQModelIndex(unsafe.Pointer(destinationParent)) + + slotval5 := (int)(destinationChild) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_MoveColumns, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_FetchMore(parent *qt.QModelIndex) { + + C.QPdfBookmarkModel_virtualbase_fetchMore(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnFetchMore(slot func(super func(parent *qt.QModelIndex), parent *qt.QModelIndex)) { + ok := C.QPdfBookmarkModel_override_virtual_fetchMore(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_fetchMore +func miqt_exec_callback_QPdfBookmarkModel_fetchMore(self *C.QPdfBookmarkModel, cb C.intptr_t, parent *C.QModelIndex) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt.QModelIndex), parent *qt.QModelIndex)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_FetchMore, slotval1) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_CanFetchMore(parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_canFetchMore(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnCanFetchMore(slot func(super func(parent *qt.QModelIndex) bool, parent *qt.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_canFetchMore(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_canFetchMore +func miqt_exec_callback_QPdfBookmarkModel_canFetchMore(self *C.QPdfBookmarkModel, cb C.intptr_t, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt.QModelIndex) bool, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_CanFetchMore, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Flags(index *qt.QModelIndex) qt.ItemFlag { + + return (qt.ItemFlag)(C.QPdfBookmarkModel_virtualbase_flags(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnFlags(slot func(super func(index *qt.QModelIndex) qt.ItemFlag, index *qt.QModelIndex) qt.ItemFlag) { + ok := C.QPdfBookmarkModel_override_virtual_flags(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_flags +func miqt_exec_callback_QPdfBookmarkModel_flags(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex) qt.ItemFlag, index *qt.QModelIndex) qt.ItemFlag) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Flags, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Sort(column int, order qt.SortOrder) { + + C.QPdfBookmarkModel_virtualbase_sort(unsafe.Pointer(this.h), (C.int)(column), (C.int)(order)) + +} +func (this *QPdfBookmarkModel) OnSort(slot func(super func(column int, order qt.SortOrder), column int, order qt.SortOrder)) { + ok := C.QPdfBookmarkModel_override_virtual_sort(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_sort +func miqt_exec_callback_QPdfBookmarkModel_sort(self *C.QPdfBookmarkModel, cb C.intptr_t, column C.int, order C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(column int, order qt.SortOrder), column int, order qt.SortOrder)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(column) + + slotval2 := (qt.SortOrder)(order) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Sort, slotval1, slotval2) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Buddy(index *qt.QModelIndex) *qt.QModelIndex { + + _goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_buddy(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnBuddy(slot func(super func(index *qt.QModelIndex) *qt.QModelIndex, index *qt.QModelIndex) *qt.QModelIndex) { + ok := C.QPdfBookmarkModel_override_virtual_buddy(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_buddy +func miqt_exec_callback_QPdfBookmarkModel_buddy(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex) *qt.QModelIndex, index *qt.QModelIndex) *qt.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Buddy, slotval1) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Match(start *qt.QModelIndex, role int, value *qt.QVariant, hits int, flags qt.MatchFlag) []qt.QModelIndex { + + var _ma C.struct_miqt_array = C.QPdfBookmarkModel_virtualbase_match(unsafe.Pointer(this.h), (*C.QModelIndex)(start.UnsafePointer()), (C.int)(role), (*C.QVariant)(value.UnsafePointer()), (C.int)(hits), (C.int)(flags)) + _ret := make([]qt.QModelIndex, int(_ma.len)) + _outCast := (*[0xffff]*C.QModelIndex)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(_outCast[i])) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret + +} +func (this *QPdfBookmarkModel) OnMatch(slot func(super func(start *qt.QModelIndex, role int, value *qt.QVariant, hits int, flags qt.MatchFlag) []qt.QModelIndex, start *qt.QModelIndex, role int, value *qt.QVariant, hits int, flags qt.MatchFlag) []qt.QModelIndex) { + ok := C.QPdfBookmarkModel_override_virtual_match(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_match +func miqt_exec_callback_QPdfBookmarkModel_match(self *C.QPdfBookmarkModel, cb C.intptr_t, start *C.QModelIndex, role C.int, value *C.QVariant, hits C.int, flags C.int) C.struct_miqt_array { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(start *qt.QModelIndex, role int, value *qt.QVariant, hits int, flags qt.MatchFlag) []qt.QModelIndex, start *qt.QModelIndex, role int, value *qt.QVariant, hits int, flags qt.MatchFlag) []qt.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(start)) + + slotval2 := (int)(role) + + slotval3 := qt.UnsafeNewQVariant(unsafe.Pointer(value)) + + slotval4 := (int)(hits) + + slotval5 := (qt.MatchFlag)(flags) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Match, slotval1, slotval2, slotval3, slotval4, slotval5) + virtualReturn_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_CArray)) + for i := range virtualReturn { + virtualReturn_CArray[i] = (*C.QModelIndex)(virtualReturn[i].UnsafePointer()) + } + virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)} + + return virtualReturn_ma + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Span(index *qt.QModelIndex) *qt.QSize { + + _goptr := qt.UnsafeNewQSize(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_span(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnSpan(slot func(super func(index *qt.QModelIndex) *qt.QSize, index *qt.QModelIndex) *qt.QSize) { + ok := C.QPdfBookmarkModel_override_virtual_span(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_span +func miqt_exec_callback_QPdfBookmarkModel_span(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex) *C.QSize { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex) *qt.QSize, index *qt.QModelIndex) *qt.QSize) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Span, slotval1) + + return (*C.QSize)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Submit() bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_submit(unsafe.Pointer(this.h))) + +} +func (this *QPdfBookmarkModel) OnSubmit(slot func(super func() bool) bool) { + ok := C.QPdfBookmarkModel_override_virtual_submit(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_submit +func miqt_exec_callback_QPdfBookmarkModel_submit(self *C.QPdfBookmarkModel, cb C.intptr_t) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Submit) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Revert() { + + C.QPdfBookmarkModel_virtualbase_revert(unsafe.Pointer(this.h)) + +} +func (this *QPdfBookmarkModel) OnRevert(slot func(super func())) { + ok := C.QPdfBookmarkModel_override_virtual_revert(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_revert +func miqt_exec_callback_QPdfBookmarkModel_revert(self *C.QPdfBookmarkModel, cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func())) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Revert) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Event(event *qt.QEvent) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnEvent(slot func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) { + ok := C.QPdfBookmarkModel_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_event +func miqt_exec_callback_QPdfBookmarkModel_event(self *C.QPdfBookmarkModel, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_EventFilter(watched *qt.QObject, event *qt.QEvent) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnEventFilter(slot func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) { + ok := C.QPdfBookmarkModel_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_eventFilter +func miqt_exec_callback_QPdfBookmarkModel_eventFilter(self *C.QPdfBookmarkModel, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_TimerEvent(event *qt.QTimerEvent) { + + C.QPdfBookmarkModel_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnTimerEvent(slot func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) { + ok := C.QPdfBookmarkModel_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_timerEvent +func miqt_exec_callback_QPdfBookmarkModel_timerEvent(self *C.QPdfBookmarkModel, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_ChildEvent(event *qt.QChildEvent) { + + C.QPdfBookmarkModel_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnChildEvent(slot func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) { + ok := C.QPdfBookmarkModel_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_childEvent +func miqt_exec_callback_QPdfBookmarkModel_childEvent(self *C.QPdfBookmarkModel, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_CustomEvent(event *qt.QEvent) { + + C.QPdfBookmarkModel_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnCustomEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) { + ok := C.QPdfBookmarkModel_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_customEvent +func miqt_exec_callback_QPdfBookmarkModel_customEvent(self *C.QPdfBookmarkModel, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_ConnectNotify(signal *qt.QMetaMethod) { + + C.QPdfBookmarkModel_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnConnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QPdfBookmarkModel_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_connectNotify +func miqt_exec_callback_QPdfBookmarkModel_connectNotify(self *C.QPdfBookmarkModel, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_DisconnectNotify(signal *qt.QMetaMethod) { + + C.QPdfBookmarkModel_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnDisconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QPdfBookmarkModel_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_disconnectNotify +func miqt_exec_callback_QPdfBookmarkModel_disconnectNotify(self *C.QPdfBookmarkModel, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QPdfBookmarkModel) Delete() { + C.QPdfBookmarkModel_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfBookmarkModel) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfBookmarkModel) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/pdf/gen_qpdfbookmarkmodel.h b/qt/pdf/gen_qpdfbookmarkmodel.h new file mode 100644 index 00000000..eb462d3a --- /dev/null +++ b/qt/pdf/gen_qpdfbookmarkmodel.h @@ -0,0 +1,187 @@ +#pragma once +#ifndef MIQT_QT_PDF_GEN_QPDFBOOKMARKMODEL_H +#define MIQT_QT_PDF_GEN_QPDFBOOKMARKMODEL_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractItemModel; +class QChildEvent; +class QDataStream; +class QEvent; +class QMetaMethod; +class QMetaObject; +class QMimeData; +class QModelIndex; +class QObject; +class QPdfBookmarkModel; +class QPdfDocument; +class QSize; +class QTimerEvent; +class QVariant; +#else +typedef struct QAbstractItemModel QAbstractItemModel; +typedef struct QChildEvent QChildEvent; +typedef struct QDataStream QDataStream; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QMimeData QMimeData; +typedef struct QModelIndex QModelIndex; +typedef struct QObject QObject; +typedef struct QPdfBookmarkModel QPdfBookmarkModel; +typedef struct QPdfDocument QPdfDocument; +typedef struct QSize QSize; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +#endif + +QPdfBookmarkModel* QPdfBookmarkModel_new(); +QPdfBookmarkModel* QPdfBookmarkModel_new2(QObject* parent); +void QPdfBookmarkModel_virtbase(QPdfBookmarkModel* src, QAbstractItemModel** outptr_QAbstractItemModel); +QMetaObject* QPdfBookmarkModel_metaObject(const QPdfBookmarkModel* self); +void* QPdfBookmarkModel_metacast(QPdfBookmarkModel* self, const char* param1); +struct miqt_string QPdfBookmarkModel_tr(const char* s); +struct miqt_string QPdfBookmarkModel_trUtf8(const char* s); +QPdfDocument* QPdfBookmarkModel_document(const QPdfBookmarkModel* self); +void QPdfBookmarkModel_setDocument(QPdfBookmarkModel* self, QPdfDocument* document); +int QPdfBookmarkModel_structureMode(const QPdfBookmarkModel* self); +void QPdfBookmarkModel_setStructureMode(QPdfBookmarkModel* self, int mode); +QVariant* QPdfBookmarkModel_data(const QPdfBookmarkModel* self, QModelIndex* index, int role); +QModelIndex* QPdfBookmarkModel_index(const QPdfBookmarkModel* self, int row, int column, QModelIndex* parent); +QModelIndex* QPdfBookmarkModel_parent(const QPdfBookmarkModel* self, QModelIndex* index); +int QPdfBookmarkModel_rowCount(const QPdfBookmarkModel* self, QModelIndex* parent); +int QPdfBookmarkModel_columnCount(const QPdfBookmarkModel* self, QModelIndex* parent); +struct miqt_map /* of int to struct miqt_string */ QPdfBookmarkModel_roleNames(const QPdfBookmarkModel* self); +void QPdfBookmarkModel_documentChanged(QPdfBookmarkModel* self, QPdfDocument* document); +void QPdfBookmarkModel_connect_documentChanged(QPdfBookmarkModel* self, intptr_t slot); +void QPdfBookmarkModel_structureModeChanged(QPdfBookmarkModel* self, int structureMode); +void QPdfBookmarkModel_connect_structureModeChanged(QPdfBookmarkModel* self, intptr_t slot); +struct miqt_string QPdfBookmarkModel_tr2(const char* s, const char* c); +struct miqt_string QPdfBookmarkModel_tr3(const char* s, const char* c, int n); +struct miqt_string QPdfBookmarkModel_trUtf82(const char* s, const char* c); +struct miqt_string QPdfBookmarkModel_trUtf83(const char* s, const char* c, int n); +bool QPdfBookmarkModel_override_virtual_data(void* self, intptr_t slot); +QVariant* QPdfBookmarkModel_virtualbase_data(const void* self, QModelIndex* index, int role); +bool QPdfBookmarkModel_override_virtual_index(void* self, intptr_t slot); +QModelIndex* QPdfBookmarkModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_parent(void* self, intptr_t slot); +QModelIndex* QPdfBookmarkModel_virtualbase_parent(const void* self, QModelIndex* index); +bool QPdfBookmarkModel_override_virtual_rowCount(void* self, intptr_t slot); +int QPdfBookmarkModel_virtualbase_rowCount(const void* self, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_columnCount(void* self, intptr_t slot); +int QPdfBookmarkModel_virtualbase_columnCount(const void* self, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_roleNames(void* self, intptr_t slot); +struct miqt_map /* of int to struct miqt_string */ QPdfBookmarkModel_virtualbase_roleNames(const void* self); +bool QPdfBookmarkModel_override_virtual_sibling(void* self, intptr_t slot); +QModelIndex* QPdfBookmarkModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx); +bool QPdfBookmarkModel_override_virtual_hasChildren(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_hasChildren(const void* self, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_setData(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role); +bool QPdfBookmarkModel_override_virtual_headerData(void* self, intptr_t slot); +QVariant* QPdfBookmarkModel_virtualbase_headerData(const void* self, int section, int orientation, int role); +bool QPdfBookmarkModel_override_virtual_setHeaderData(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role); +bool QPdfBookmarkModel_override_virtual_itemData(void* self, intptr_t slot); +struct miqt_map /* of int to QVariant* */ QPdfBookmarkModel_virtualbase_itemData(const void* self, QModelIndex* index); +bool QPdfBookmarkModel_override_virtual_setItemData(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */ roles); +bool QPdfBookmarkModel_override_virtual_mimeTypes(void* self, intptr_t slot); +struct miqt_array /* of struct miqt_string */ QPdfBookmarkModel_virtualbase_mimeTypes(const void* self); +bool QPdfBookmarkModel_override_virtual_mimeData(void* self, intptr_t slot); +QMimeData* QPdfBookmarkModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes); +bool QPdfBookmarkModel_override_virtual_canDropMimeData(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_dropMimeData(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_supportedDropActions(void* self, intptr_t slot); +int QPdfBookmarkModel_virtualbase_supportedDropActions(const void* self); +bool QPdfBookmarkModel_override_virtual_supportedDragActions(void* self, intptr_t slot); +int QPdfBookmarkModel_virtualbase_supportedDragActions(const void* self); +bool QPdfBookmarkModel_override_virtual_insertRows(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_insertColumns(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_removeRows(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_removeColumns(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_moveRows(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild); +bool QPdfBookmarkModel_override_virtual_moveColumns(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild); +bool QPdfBookmarkModel_override_virtual_fetchMore(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_fetchMore(void* self, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_canFetchMore(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_flags(void* self, intptr_t slot); +int QPdfBookmarkModel_virtualbase_flags(const void* self, QModelIndex* index); +bool QPdfBookmarkModel_override_virtual_sort(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_sort(void* self, int column, int order); +bool QPdfBookmarkModel_override_virtual_buddy(void* self, intptr_t slot); +QModelIndex* QPdfBookmarkModel_virtualbase_buddy(const void* self, QModelIndex* index); +bool QPdfBookmarkModel_override_virtual_match(void* self, intptr_t slot); +struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); +bool QPdfBookmarkModel_override_virtual_span(void* self, intptr_t slot); +QSize* QPdfBookmarkModel_virtualbase_span(const void* self, QModelIndex* index); +bool QPdfBookmarkModel_override_virtual_submit(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_submit(void* self); +bool QPdfBookmarkModel_override_virtual_revert(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_revert(void* self); +bool QPdfBookmarkModel_override_virtual_event(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_event(void* self, QEvent* event); +bool QPdfBookmarkModel_override_virtual_eventFilter(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QPdfBookmarkModel_override_virtual_timerEvent(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QPdfBookmarkModel_override_virtual_childEvent(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_childEvent(void* self, QChildEvent* event); +bool QPdfBookmarkModel_override_virtual_customEvent(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_customEvent(void* self, QEvent* event); +bool QPdfBookmarkModel_override_virtual_connectNotify(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QPdfBookmarkModel_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); +void QPdfBookmarkModel_protectedbase_resetInternalData(bool* _dynamic_cast_ok, void* self); +QModelIndex* QPdfBookmarkModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column); +void QPdfBookmarkModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */ indexes, QDataStream* stream); +bool QPdfBookmarkModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream); +void QPdfBookmarkModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfBookmarkModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self); +void QPdfBookmarkModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfBookmarkModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self); +bool QPdfBookmarkModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow); +void QPdfBookmarkModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self); +void QPdfBookmarkModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfBookmarkModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self); +void QPdfBookmarkModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfBookmarkModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self); +bool QPdfBookmarkModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn); +void QPdfBookmarkModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self); +void QPdfBookmarkModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self); +void QPdfBookmarkModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self); +void QPdfBookmarkModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to); +void QPdfBookmarkModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */ from, struct miqt_array /* of QModelIndex* */ to); +struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self); +QObject* QPdfBookmarkModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QPdfBookmarkModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QPdfBookmarkModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QPdfBookmarkModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +void QPdfBookmarkModel_delete(QPdfBookmarkModel* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/pdf/gen_qpdfdestination.cpp b/qt/pdf/gen_qpdfdestination.cpp new file mode 100644 index 00000000..30c31e6e --- /dev/null +++ b/qt/pdf/gen_qpdfdestination.cpp @@ -0,0 +1,46 @@ +#include +#include +#include +#include "gen_qpdfdestination.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +QPdfDestination* QPdfDestination_new(QPdfDestination* other) { + return new QPdfDestination(*other); +} + +void QPdfDestination_operatorAssign(QPdfDestination* self, QPdfDestination* other) { + self->operator=(*other); +} + +void QPdfDestination_swap(QPdfDestination* self, QPdfDestination* other) { + self->swap(*other); +} + +bool QPdfDestination_isValid(const QPdfDestination* self) { + return self->isValid(); +} + +int QPdfDestination_page(const QPdfDestination* self) { + return self->page(); +} + +QPointF* QPdfDestination_location(const QPdfDestination* self) { + return new QPointF(self->location()); +} + +double QPdfDestination_zoom(const QPdfDestination* self) { + qreal _ret = self->zoom(); + return static_cast(_ret); +} + +void QPdfDestination_delete(QPdfDestination* self) { + delete self; +} + diff --git a/qt/pdf/gen_qpdfdestination.go b/qt/pdf/gen_qpdfdestination.go new file mode 100644 index 00000000..31f76e82 --- /dev/null +++ b/qt/pdf/gen_qpdfdestination.go @@ -0,0 +1,93 @@ +package pdf + +/* + +#include "gen_qpdfdestination.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "runtime" + "unsafe" +) + +type QPdfDestination struct { + h *C.QPdfDestination +} + +func (this *QPdfDestination) cPointer() *C.QPdfDestination { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfDestination) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfDestination constructs the type using only CGO pointers. +func newQPdfDestination(h *C.QPdfDestination) *QPdfDestination { + if h == nil { + return nil + } + + return &QPdfDestination{h: h} +} + +// UnsafeNewQPdfDestination constructs the type using only unsafe pointers. +func UnsafeNewQPdfDestination(h unsafe.Pointer) *QPdfDestination { + return newQPdfDestination((*C.QPdfDestination)(h)) +} + +// NewQPdfDestination constructs a new QPdfDestination object. +func NewQPdfDestination(other *QPdfDestination) *QPdfDestination { + + return newQPdfDestination(C.QPdfDestination_new(other.cPointer())) +} + +func (this *QPdfDestination) OperatorAssign(other *QPdfDestination) { + C.QPdfDestination_operatorAssign(this.h, other.cPointer()) +} + +func (this *QPdfDestination) Swap(other *QPdfDestination) { + C.QPdfDestination_swap(this.h, other.cPointer()) +} + +func (this *QPdfDestination) IsValid() bool { + return (bool)(C.QPdfDestination_isValid(this.h)) +} + +func (this *QPdfDestination) Page() int { + return (int)(C.QPdfDestination_page(this.h)) +} + +func (this *QPdfDestination) Location() *qt.QPointF { + _goptr := qt.UnsafeNewQPointF(unsafe.Pointer(C.QPdfDestination_location(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDestination) Zoom() float64 { + return (float64)(C.QPdfDestination_zoom(this.h)) +} + +// Delete this object from C++ memory. +func (this *QPdfDestination) Delete() { + C.QPdfDestination_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfDestination) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfDestination) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/pdf/gen_qpdfdestination.h b/qt/pdf/gen_qpdfdestination.h new file mode 100644 index 00000000..ff9ebe1d --- /dev/null +++ b/qt/pdf/gen_qpdfdestination.h @@ -0,0 +1,38 @@ +#pragma once +#ifndef MIQT_QT_PDF_GEN_QPDFDESTINATION_H +#define MIQT_QT_PDF_GEN_QPDFDESTINATION_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QPdfDestination; +class QPointF; +#else +typedef struct QPdfDestination QPdfDestination; +typedef struct QPointF QPointF; +#endif + +QPdfDestination* QPdfDestination_new(QPdfDestination* other); +void QPdfDestination_operatorAssign(QPdfDestination* self, QPdfDestination* other); +void QPdfDestination_swap(QPdfDestination* self, QPdfDestination* other); +bool QPdfDestination_isValid(const QPdfDestination* self); +int QPdfDestination_page(const QPdfDestination* self); +QPointF* QPdfDestination_location(const QPdfDestination* self); +double QPdfDestination_zoom(const QPdfDestination* self); +void QPdfDestination_delete(QPdfDestination* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/pdf/gen_qpdfdocument.cpp b/qt/pdf/gen_qpdfdocument.cpp new file mode 100644 index 00000000..cd3530b4 --- /dev/null +++ b/qt/pdf/gen_qpdfdocument.cpp @@ -0,0 +1,560 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qpdfdocument.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QPdfDocument_passwordChanged(intptr_t); +void miqt_exec_callback_QPdfDocument_passwordRequired(intptr_t); +void miqt_exec_callback_QPdfDocument_statusChanged(intptr_t, int); +void miqt_exec_callback_QPdfDocument_pageCountChanged(intptr_t, int); +bool miqt_exec_callback_QPdfDocument_event(QPdfDocument*, intptr_t, QEvent*); +bool miqt_exec_callback_QPdfDocument_eventFilter(QPdfDocument*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QPdfDocument_timerEvent(QPdfDocument*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QPdfDocument_childEvent(QPdfDocument*, intptr_t, QChildEvent*); +void miqt_exec_callback_QPdfDocument_customEvent(QPdfDocument*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfDocument_connectNotify(QPdfDocument*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QPdfDocument_disconnectNotify(QPdfDocument*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQPdfDocument final : public QPdfDocument { +public: + + MiqtVirtualQPdfDocument(): QPdfDocument() {}; + MiqtVirtualQPdfDocument(QObject* parent): QPdfDocument(parent) {}; + + virtual ~MiqtVirtualQPdfDocument() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QPdfDocument::event(event); + } + + QEvent* sigval1 = event; + + bool callback_return_value = miqt_exec_callback_QPdfDocument_event(this, handle__event, sigval1); + + return callback_return_value; + } + + friend bool QPdfDocument_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QPdfDocument::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + + bool callback_return_value = miqt_exec_callback_QPdfDocument_eventFilter(this, handle__eventFilter, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfDocument_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__timerEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void timerEvent(QTimerEvent* event) override { + if (handle__timerEvent == 0) { + QPdfDocument::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + + miqt_exec_callback_QPdfDocument_timerEvent(this, handle__timerEvent, sigval1); + + + } + + friend void QPdfDocument_virtualbase_timerEvent(void* self, QTimerEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__childEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void childEvent(QChildEvent* event) override { + if (handle__childEvent == 0) { + QPdfDocument::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + + miqt_exec_callback_QPdfDocument_childEvent(this, handle__childEvent, sigval1); + + + } + + friend void QPdfDocument_virtualbase_childEvent(void* self, QChildEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__customEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void customEvent(QEvent* event) override { + if (handle__customEvent == 0) { + QPdfDocument::customEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfDocument_customEvent(this, handle__customEvent, sigval1); + + + } + + friend void QPdfDocument_virtualbase_customEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__connectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void connectNotify(const QMetaMethod& signal) override { + if (handle__connectNotify == 0) { + QPdfDocument::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfDocument_connectNotify(this, handle__connectNotify, sigval1); + + + } + + friend void QPdfDocument_virtualbase_connectNotify(void* self, QMetaMethod* signal); + + // cgo.Handle value for overwritten implementation + intptr_t handle__disconnectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void disconnectNotify(const QMetaMethod& signal) override { + if (handle__disconnectNotify == 0) { + QPdfDocument::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfDocument_disconnectNotify(this, handle__disconnectNotify, sigval1); + + + } + + friend void QPdfDocument_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QPdfDocument_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QPdfDocument_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QPdfDocument_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QPdfDocument_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QPdfDocument* QPdfDocument_new() { + return new MiqtVirtualQPdfDocument(); +} + +QPdfDocument* QPdfDocument_new2(QObject* parent) { + return new MiqtVirtualQPdfDocument(parent); +} + +void QPdfDocument_virtbase(QPdfDocument* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QPdfDocument_metaObject(const QPdfDocument* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QPdfDocument_metacast(QPdfDocument* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QPdfDocument_tr(const char* s) { + QString _ret = QPdfDocument::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 QPdfDocument_trUtf8(const char* s) { + QString _ret = QPdfDocument::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; +} + +int QPdfDocument_load(QPdfDocument* self, struct miqt_string fileName) { + QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); + QPdfDocument::DocumentError _ret = self->load(fileName_QString); + return static_cast(_ret); +} + +int QPdfDocument_status(const QPdfDocument* self) { + QPdfDocument::Status _ret = self->status(); + return static_cast(_ret); +} + +void QPdfDocument_loadWithDevice(QPdfDocument* self, QIODevice* device) { + self->load(device); +} + +void QPdfDocument_setPassword(QPdfDocument* self, struct miqt_string password) { + QString password_QString = QString::fromUtf8(password.data, password.len); + self->setPassword(password_QString); +} + +struct miqt_string QPdfDocument_password(const QPdfDocument* self) { + QString _ret = self->password(); + // 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; +} + +QVariant* QPdfDocument_metaData(const QPdfDocument* self, int field) { + return new QVariant(self->metaData(static_cast(field))); +} + +int QPdfDocument_error(const QPdfDocument* self) { + QPdfDocument::DocumentError _ret = self->error(); + return static_cast(_ret); +} + +void QPdfDocument_close(QPdfDocument* self) { + self->close(); +} + +int QPdfDocument_pageCount(const QPdfDocument* self) { + return self->pageCount(); +} + +QSizeF* QPdfDocument_pageSize(const QPdfDocument* self, int page) { + return new QSizeF(self->pageSize(static_cast(page))); +} + +QImage* QPdfDocument_render(QPdfDocument* self, int page, QSize* imageSize) { + return new QImage(self->render(static_cast(page), *imageSize)); +} + +QPdfSelection* QPdfDocument_getSelection(QPdfDocument* self, int page, QPointF* start, QPointF* end) { + return new QPdfSelection(self->getSelection(static_cast(page), *start, *end)); +} + +QPdfSelection* QPdfDocument_getSelectionAtIndex(QPdfDocument* self, int page, int startIndex, int maxLength) { + return new QPdfSelection(self->getSelectionAtIndex(static_cast(page), static_cast(startIndex), static_cast(maxLength))); +} + +QPdfSelection* QPdfDocument_getAllText(QPdfDocument* self, int page) { + return new QPdfSelection(self->getAllText(static_cast(page))); +} + +void QPdfDocument_passwordChanged(QPdfDocument* self) { + self->passwordChanged(); +} + +void QPdfDocument_connect_passwordChanged(QPdfDocument* self, intptr_t slot) { + MiqtVirtualQPdfDocument::connect(self, static_cast(&QPdfDocument::passwordChanged), self, [=]() { + miqt_exec_callback_QPdfDocument_passwordChanged(slot); + }); +} + +void QPdfDocument_passwordRequired(QPdfDocument* self) { + self->passwordRequired(); +} + +void QPdfDocument_connect_passwordRequired(QPdfDocument* self, intptr_t slot) { + MiqtVirtualQPdfDocument::connect(self, static_cast(&QPdfDocument::passwordRequired), self, [=]() { + miqt_exec_callback_QPdfDocument_passwordRequired(slot); + }); +} + +void QPdfDocument_statusChanged(QPdfDocument* self, int status) { + self->statusChanged(static_cast(status)); +} + +void QPdfDocument_connect_statusChanged(QPdfDocument* self, intptr_t slot) { + MiqtVirtualQPdfDocument::connect(self, static_cast(&QPdfDocument::statusChanged), self, [=](QPdfDocument::Status status) { + QPdfDocument::Status status_ret = status; + int sigval1 = static_cast(status_ret); + miqt_exec_callback_QPdfDocument_statusChanged(slot, sigval1); + }); +} + +void QPdfDocument_pageCountChanged(QPdfDocument* self, int pageCount) { + self->pageCountChanged(static_cast(pageCount)); +} + +void QPdfDocument_connect_pageCountChanged(QPdfDocument* self, intptr_t slot) { + MiqtVirtualQPdfDocument::connect(self, static_cast(&QPdfDocument::pageCountChanged), self, [=](int pageCount) { + int sigval1 = pageCount; + miqt_exec_callback_QPdfDocument_pageCountChanged(slot, sigval1); + }); +} + +struct miqt_string QPdfDocument_tr2(const char* s, const char* c) { + QString _ret = QPdfDocument::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 QPdfDocument_tr3(const char* s, const char* c, int n) { + QString _ret = QPdfDocument::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 QPdfDocument_trUtf82(const char* s, const char* c) { + QString _ret = QPdfDocument::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 QPdfDocument_trUtf83(const char* s, const char* c, int n) { + QString _ret = QPdfDocument::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; +} + +QImage* QPdfDocument_render2(QPdfDocument* self, int page, QSize* imageSize, QPdfDocumentRenderOptions* options) { + return new QImage(self->render(static_cast(page), *imageSize, *options)); +} + +bool QPdfDocument_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QPdfDocument_virtualbase_event(void* self, QEvent* event) { + + return ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::event(event); + +} + +bool QPdfDocument_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QPdfDocument_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + + return ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::eventFilter(watched, event); + +} + +bool QPdfDocument_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QPdfDocument_virtualbase_timerEvent(void* self, QTimerEvent* event) { + + ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::timerEvent(event); + +} + +bool QPdfDocument_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QPdfDocument_virtualbase_childEvent(void* self, QChildEvent* event) { + + ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::childEvent(event); + +} + +bool QPdfDocument_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QPdfDocument_virtualbase_customEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::customEvent(event); + +} + +bool QPdfDocument_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QPdfDocument_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::connectNotify(*signal); + +} + +bool QPdfDocument_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QPdfDocument_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::disconnectNotify(*signal); + +} + +QObject* QPdfDocument_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return self_cast->sender(); + +} + +int QPdfDocument_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->senderSignalIndex(); + +} + +int QPdfDocument_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->receivers(signal); + +} + +bool QPdfDocument_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->isSignalConnected(*signal); + +} + +void QPdfDocument_delete(QPdfDocument* self) { + delete self; +} + diff --git a/qt/pdf/gen_qpdfdocument.go b/qt/pdf/gen_qpdfdocument.go new file mode 100644 index 00000000..66412fa9 --- /dev/null +++ b/qt/pdf/gen_qpdfdocument.go @@ -0,0 +1,590 @@ +package pdf + +/* + +#include "gen_qpdfdocument.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QPdfDocument__Status int + +const ( + QPdfDocument__Null QPdfDocument__Status = 0 + QPdfDocument__Loading QPdfDocument__Status = 1 + QPdfDocument__Ready QPdfDocument__Status = 2 + QPdfDocument__Unloading QPdfDocument__Status = 3 + QPdfDocument__Error QPdfDocument__Status = 4 +) + +type QPdfDocument__DocumentError int + +const ( + QPdfDocument__NoError QPdfDocument__DocumentError = 0 + QPdfDocument__UnknownError QPdfDocument__DocumentError = 1 + QPdfDocument__DataNotYetAvailableError QPdfDocument__DocumentError = 2 + QPdfDocument__FileNotFoundError QPdfDocument__DocumentError = 3 + QPdfDocument__InvalidFileFormatError QPdfDocument__DocumentError = 4 + QPdfDocument__IncorrectPasswordError QPdfDocument__DocumentError = 5 + QPdfDocument__UnsupportedSecuritySchemeError QPdfDocument__DocumentError = 6 +) + +type QPdfDocument__MetaDataField int + +const ( + QPdfDocument__Title QPdfDocument__MetaDataField = 0 + QPdfDocument__Subject QPdfDocument__MetaDataField = 1 + QPdfDocument__Author QPdfDocument__MetaDataField = 2 + QPdfDocument__Keywords QPdfDocument__MetaDataField = 3 + QPdfDocument__Producer QPdfDocument__MetaDataField = 4 + QPdfDocument__Creator QPdfDocument__MetaDataField = 5 + QPdfDocument__CreationDate QPdfDocument__MetaDataField = 6 + QPdfDocument__ModificationDate QPdfDocument__MetaDataField = 7 +) + +type QPdfDocument struct { + h *C.QPdfDocument + *qt.QObject +} + +func (this *QPdfDocument) cPointer() *C.QPdfDocument { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfDocument) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfDocument constructs the type using only CGO pointers. +func newQPdfDocument(h *C.QPdfDocument) *QPdfDocument { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QPdfDocument_virtbase(h, &outptr_QObject) + + return &QPdfDocument{h: h, + QObject: qt.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQPdfDocument constructs the type using only unsafe pointers. +func UnsafeNewQPdfDocument(h unsafe.Pointer) *QPdfDocument { + return newQPdfDocument((*C.QPdfDocument)(h)) +} + +// NewQPdfDocument constructs a new QPdfDocument object. +func NewQPdfDocument() *QPdfDocument { + + return newQPdfDocument(C.QPdfDocument_new()) +} + +// NewQPdfDocument2 constructs a new QPdfDocument object. +func NewQPdfDocument2(parent *qt.QObject) *QPdfDocument { + + return newQPdfDocument(C.QPdfDocument_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QPdfDocument) MetaObject() *qt.QMetaObject { + return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QPdfDocument_metaObject(this.h))) +} + +func (this *QPdfDocument) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QPdfDocument_metacast(this.h, param1_Cstring)) +} + +func QPdfDocument_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfDocument_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfDocument_TrUtf8(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfDocument_trUtf8(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfDocument) Load(fileName string) QPdfDocument__DocumentError { + fileName_ms := C.struct_miqt_string{} + fileName_ms.data = C.CString(fileName) + fileName_ms.len = C.size_t(len(fileName)) + defer C.free(unsafe.Pointer(fileName_ms.data)) + return (QPdfDocument__DocumentError)(C.QPdfDocument_load(this.h, fileName_ms)) +} + +func (this *QPdfDocument) Status() QPdfDocument__Status { + return (QPdfDocument__Status)(C.QPdfDocument_status(this.h)) +} + +func (this *QPdfDocument) LoadWithDevice(device *qt.QIODevice) { + C.QPdfDocument_loadWithDevice(this.h, (*C.QIODevice)(device.UnsafePointer())) +} + +func (this *QPdfDocument) SetPassword(password string) { + password_ms := C.struct_miqt_string{} + password_ms.data = C.CString(password) + password_ms.len = C.size_t(len(password)) + defer C.free(unsafe.Pointer(password_ms.data)) + C.QPdfDocument_setPassword(this.h, password_ms) +} + +func (this *QPdfDocument) Password() string { + var _ms C.struct_miqt_string = C.QPdfDocument_password(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfDocument) MetaData(field QPdfDocument__MetaDataField) *qt.QVariant { + _goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QPdfDocument_metaData(this.h, (C.int)(field)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocument) Error() QPdfDocument__DocumentError { + return (QPdfDocument__DocumentError)(C.QPdfDocument_error(this.h)) +} + +func (this *QPdfDocument) Close() { + C.QPdfDocument_close(this.h) +} + +func (this *QPdfDocument) PageCount() int { + return (int)(C.QPdfDocument_pageCount(this.h)) +} + +func (this *QPdfDocument) PageSize(page int) *qt.QSizeF { + _goptr := qt.UnsafeNewQSizeF(unsafe.Pointer(C.QPdfDocument_pageSize(this.h, (C.int)(page)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocument) Render(page int, imageSize qt.QSize) *qt.QImage { + _goptr := qt.UnsafeNewQImage(unsafe.Pointer(C.QPdfDocument_render(this.h, (C.int)(page), (*C.QSize)(imageSize.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocument) GetSelection(page int, start qt.QPointF, end qt.QPointF) *QPdfSelection { + _goptr := newQPdfSelection(C.QPdfDocument_getSelection(this.h, (C.int)(page), (*C.QPointF)(start.UnsafePointer()), (*C.QPointF)(end.UnsafePointer()))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocument) GetSelectionAtIndex(page int, startIndex int, maxLength int) *QPdfSelection { + _goptr := newQPdfSelection(C.QPdfDocument_getSelectionAtIndex(this.h, (C.int)(page), (C.int)(startIndex), (C.int)(maxLength))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocument) GetAllText(page int) *QPdfSelection { + _goptr := newQPdfSelection(C.QPdfDocument_getAllText(this.h, (C.int)(page))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocument) PasswordChanged() { + C.QPdfDocument_passwordChanged(this.h) +} +func (this *QPdfDocument) OnPasswordChanged(slot func()) { + C.QPdfDocument_connect_passwordChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfDocument_passwordChanged +func miqt_exec_callback_QPdfDocument_passwordChanged(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *QPdfDocument) PasswordRequired() { + C.QPdfDocument_passwordRequired(this.h) +} +func (this *QPdfDocument) OnPasswordRequired(slot func()) { + C.QPdfDocument_connect_passwordRequired(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfDocument_passwordRequired +func miqt_exec_callback_QPdfDocument_passwordRequired(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *QPdfDocument) StatusChanged(status QPdfDocument__Status) { + C.QPdfDocument_statusChanged(this.h, (C.int)(status)) +} +func (this *QPdfDocument) OnStatusChanged(slot func(status QPdfDocument__Status)) { + C.QPdfDocument_connect_statusChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfDocument_statusChanged +func miqt_exec_callback_QPdfDocument_statusChanged(cb C.intptr_t, status C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(status QPdfDocument__Status)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (QPdfDocument__Status)(status) + + gofunc(slotval1) +} + +func (this *QPdfDocument) PageCountChanged(pageCount int) { + C.QPdfDocument_pageCountChanged(this.h, (C.int)(pageCount)) +} +func (this *QPdfDocument) OnPageCountChanged(slot func(pageCount int)) { + C.QPdfDocument_connect_pageCountChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfDocument_pageCountChanged +func miqt_exec_callback_QPdfDocument_pageCountChanged(cb C.intptr_t, pageCount C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(pageCount int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(pageCount) + + gofunc(slotval1) +} + +func QPdfDocument_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfDocument_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfDocument_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfDocument_tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfDocument_TrUtf82(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfDocument_trUtf82(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfDocument_TrUtf83(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfDocument_trUtf83(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfDocument) Render2(page int, imageSize qt.QSize, options QPdfDocumentRenderOptions) *qt.QImage { + _goptr := qt.UnsafeNewQImage(unsafe.Pointer(C.QPdfDocument_render2(this.h, (C.int)(page), (*C.QSize)(imageSize.UnsafePointer()), options.cPointer()))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +// Sender can only be called from a QPdfDocument that was directly constructed. +func (this *QPdfDocument) Sender() *qt.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt.UnsafeNewQObject(unsafe.Pointer(C.QPdfDocument_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// SenderSignalIndex can only be called from a QPdfDocument that was directly constructed. +func (this *QPdfDocument) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfDocument_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Receivers can only be called from a QPdfDocument that was directly constructed. +func (this *QPdfDocument) Receivers(signal string) int { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfDocument_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// IsSignalConnected can only be called from a QPdfDocument that was directly constructed. +func (this *QPdfDocument) IsSignalConnected(signal *qt.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfDocument_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +func (this *QPdfDocument) callVirtualBase_Event(event *qt.QEvent) bool { + + return (bool)(C.QPdfDocument_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfDocument) OnEvent(slot func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) { + ok := C.QPdfDocument_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_event +func miqt_exec_callback_QPdfDocument_event(self *C.QPdfDocument, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfDocument{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfDocument) callVirtualBase_EventFilter(watched *qt.QObject, event *qt.QEvent) bool { + + return (bool)(C.QPdfDocument_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfDocument) OnEventFilter(slot func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) { + ok := C.QPdfDocument_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_eventFilter +func miqt_exec_callback_QPdfDocument_eventFilter(self *C.QPdfDocument, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfDocument{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfDocument) callVirtualBase_TimerEvent(event *qt.QTimerEvent) { + + C.QPdfDocument_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QPdfDocument) OnTimerEvent(slot func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) { + ok := C.QPdfDocument_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_timerEvent +func miqt_exec_callback_QPdfDocument_timerEvent(self *C.QPdfDocument, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QPdfDocument{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QPdfDocument) callVirtualBase_ChildEvent(event *qt.QChildEvent) { + + C.QPdfDocument_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QPdfDocument) OnChildEvent(slot func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) { + ok := C.QPdfDocument_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_childEvent +func miqt_exec_callback_QPdfDocument_childEvent(self *C.QPdfDocument, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QPdfDocument{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QPdfDocument) callVirtualBase_CustomEvent(event *qt.QEvent) { + + C.QPdfDocument_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfDocument) OnCustomEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) { + ok := C.QPdfDocument_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_customEvent +func miqt_exec_callback_QPdfDocument_customEvent(self *C.QPdfDocument, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfDocument{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QPdfDocument) callVirtualBase_ConnectNotify(signal *qt.QMetaMethod) { + + C.QPdfDocument_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfDocument) OnConnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QPdfDocument_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_connectNotify +func miqt_exec_callback_QPdfDocument_connectNotify(self *C.QPdfDocument, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfDocument{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QPdfDocument) callVirtualBase_DisconnectNotify(signal *qt.QMetaMethod) { + + C.QPdfDocument_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfDocument) OnDisconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QPdfDocument_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_disconnectNotify +func miqt_exec_callback_QPdfDocument_disconnectNotify(self *C.QPdfDocument, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfDocument{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QPdfDocument) Delete() { + C.QPdfDocument_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfDocument) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfDocument) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/pdf/gen_qpdfdocument.h b/qt/pdf/gen_qpdfdocument.h new file mode 100644 index 00000000..506d1547 --- /dev/null +++ b/qt/pdf/gen_qpdfdocument.h @@ -0,0 +1,109 @@ +#pragma once +#ifndef MIQT_QT_PDF_GEN_QPDFDOCUMENT_H +#define MIQT_QT_PDF_GEN_QPDFDOCUMENT_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QChildEvent; +class QEvent; +class QIODevice; +class QImage; +class QMetaMethod; +class QMetaObject; +class QObject; +class QPdfDocument; +class QPdfDocumentRenderOptions; +class QPdfSelection; +class QPointF; +class QSize; +class QSizeF; +class QTimerEvent; +class QVariant; +#else +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QIODevice QIODevice; +typedef struct QImage QImage; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QPdfDocument QPdfDocument; +typedef struct QPdfDocumentRenderOptions QPdfDocumentRenderOptions; +typedef struct QPdfSelection QPdfSelection; +typedef struct QPointF QPointF; +typedef struct QSize QSize; +typedef struct QSizeF QSizeF; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +#endif + +QPdfDocument* QPdfDocument_new(); +QPdfDocument* QPdfDocument_new2(QObject* parent); +void QPdfDocument_virtbase(QPdfDocument* src, QObject** outptr_QObject); +QMetaObject* QPdfDocument_metaObject(const QPdfDocument* self); +void* QPdfDocument_metacast(QPdfDocument* self, const char* param1); +struct miqt_string QPdfDocument_tr(const char* s); +struct miqt_string QPdfDocument_trUtf8(const char* s); +int QPdfDocument_load(QPdfDocument* self, struct miqt_string fileName); +int QPdfDocument_status(const QPdfDocument* self); +void QPdfDocument_loadWithDevice(QPdfDocument* self, QIODevice* device); +void QPdfDocument_setPassword(QPdfDocument* self, struct miqt_string password); +struct miqt_string QPdfDocument_password(const QPdfDocument* self); +QVariant* QPdfDocument_metaData(const QPdfDocument* self, int field); +int QPdfDocument_error(const QPdfDocument* self); +void QPdfDocument_close(QPdfDocument* self); +int QPdfDocument_pageCount(const QPdfDocument* self); +QSizeF* QPdfDocument_pageSize(const QPdfDocument* self, int page); +QImage* QPdfDocument_render(QPdfDocument* self, int page, QSize* imageSize); +QPdfSelection* QPdfDocument_getSelection(QPdfDocument* self, int page, QPointF* start, QPointF* end); +QPdfSelection* QPdfDocument_getSelectionAtIndex(QPdfDocument* self, int page, int startIndex, int maxLength); +QPdfSelection* QPdfDocument_getAllText(QPdfDocument* self, int page); +void QPdfDocument_passwordChanged(QPdfDocument* self); +void QPdfDocument_connect_passwordChanged(QPdfDocument* self, intptr_t slot); +void QPdfDocument_passwordRequired(QPdfDocument* self); +void QPdfDocument_connect_passwordRequired(QPdfDocument* self, intptr_t slot); +void QPdfDocument_statusChanged(QPdfDocument* self, int status); +void QPdfDocument_connect_statusChanged(QPdfDocument* self, intptr_t slot); +void QPdfDocument_pageCountChanged(QPdfDocument* self, int pageCount); +void QPdfDocument_connect_pageCountChanged(QPdfDocument* self, intptr_t slot); +struct miqt_string QPdfDocument_tr2(const char* s, const char* c); +struct miqt_string QPdfDocument_tr3(const char* s, const char* c, int n); +struct miqt_string QPdfDocument_trUtf82(const char* s, const char* c); +struct miqt_string QPdfDocument_trUtf83(const char* s, const char* c, int n); +QImage* QPdfDocument_render2(QPdfDocument* self, int page, QSize* imageSize, QPdfDocumentRenderOptions* options); +bool QPdfDocument_override_virtual_event(void* self, intptr_t slot); +bool QPdfDocument_virtualbase_event(void* self, QEvent* event); +bool QPdfDocument_override_virtual_eventFilter(void* self, intptr_t slot); +bool QPdfDocument_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QPdfDocument_override_virtual_timerEvent(void* self, intptr_t slot); +void QPdfDocument_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QPdfDocument_override_virtual_childEvent(void* self, intptr_t slot); +void QPdfDocument_virtualbase_childEvent(void* self, QChildEvent* event); +bool QPdfDocument_override_virtual_customEvent(void* self, intptr_t slot); +void QPdfDocument_virtualbase_customEvent(void* self, QEvent* event); +bool QPdfDocument_override_virtual_connectNotify(void* self, intptr_t slot); +void QPdfDocument_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QPdfDocument_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QPdfDocument_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); +QObject* QPdfDocument_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QPdfDocument_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QPdfDocument_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QPdfDocument_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +void QPdfDocument_delete(QPdfDocument* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/pdf/gen_qpdfdocumentrenderoptions.cpp b/qt/pdf/gen_qpdfdocumentrenderoptions.cpp new file mode 100644 index 00000000..5a566fc0 --- /dev/null +++ b/qt/pdf/gen_qpdfdocumentrenderoptions.cpp @@ -0,0 +1,60 @@ +#include +#include +#include +#include +#include "gen_qpdfdocumentrenderoptions.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +QPdfDocumentRenderOptions* QPdfDocumentRenderOptions_new() { + return new QPdfDocumentRenderOptions(); +} + +QPdfDocumentRenderOptions* QPdfDocumentRenderOptions_new2(QPdfDocumentRenderOptions* param1) { + return new QPdfDocumentRenderOptions(*param1); +} + +int QPdfDocumentRenderOptions_rotation(const QPdfDocumentRenderOptions* self) { + QPdf::Rotation _ret = self->rotation(); + return static_cast(_ret); +} + +void QPdfDocumentRenderOptions_setRotation(QPdfDocumentRenderOptions* self, int r) { + self->setRotation(static_cast(r)); +} + +int QPdfDocumentRenderOptions_renderFlags(const QPdfDocumentRenderOptions* self) { + QPdf::RenderFlags _ret = self->renderFlags(); + return static_cast(_ret); +} + +void QPdfDocumentRenderOptions_setRenderFlags(QPdfDocumentRenderOptions* self, int r) { + self->setRenderFlags(static_cast(r)); +} + +QRect* QPdfDocumentRenderOptions_scaledClipRect(const QPdfDocumentRenderOptions* self) { + return new QRect(self->scaledClipRect()); +} + +void QPdfDocumentRenderOptions_setScaledClipRect(QPdfDocumentRenderOptions* self, QRect* r) { + self->setScaledClipRect(*r); +} + +QSize* QPdfDocumentRenderOptions_scaledSize(const QPdfDocumentRenderOptions* self) { + return new QSize(self->scaledSize()); +} + +void QPdfDocumentRenderOptions_setScaledSize(QPdfDocumentRenderOptions* self, QSize* s) { + self->setScaledSize(*s); +} + +void QPdfDocumentRenderOptions_delete(QPdfDocumentRenderOptions* self) { + delete self; +} + diff --git a/qt/pdf/gen_qpdfdocumentrenderoptions.go b/qt/pdf/gen_qpdfdocumentrenderoptions.go new file mode 100644 index 00000000..aab3d9ae --- /dev/null +++ b/qt/pdf/gen_qpdfdocumentrenderoptions.go @@ -0,0 +1,109 @@ +package pdf + +/* + +#include "gen_qpdfdocumentrenderoptions.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "runtime" + "unsafe" +) + +type QPdfDocumentRenderOptions struct { + h *C.QPdfDocumentRenderOptions +} + +func (this *QPdfDocumentRenderOptions) cPointer() *C.QPdfDocumentRenderOptions { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfDocumentRenderOptions) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfDocumentRenderOptions constructs the type using only CGO pointers. +func newQPdfDocumentRenderOptions(h *C.QPdfDocumentRenderOptions) *QPdfDocumentRenderOptions { + if h == nil { + return nil + } + + return &QPdfDocumentRenderOptions{h: h} +} + +// UnsafeNewQPdfDocumentRenderOptions constructs the type using only unsafe pointers. +func UnsafeNewQPdfDocumentRenderOptions(h unsafe.Pointer) *QPdfDocumentRenderOptions { + return newQPdfDocumentRenderOptions((*C.QPdfDocumentRenderOptions)(h)) +} + +// NewQPdfDocumentRenderOptions constructs a new QPdfDocumentRenderOptions object. +func NewQPdfDocumentRenderOptions() *QPdfDocumentRenderOptions { + + return newQPdfDocumentRenderOptions(C.QPdfDocumentRenderOptions_new()) +} + +// NewQPdfDocumentRenderOptions2 constructs a new QPdfDocumentRenderOptions object. +func NewQPdfDocumentRenderOptions2(param1 *QPdfDocumentRenderOptions) *QPdfDocumentRenderOptions { + + return newQPdfDocumentRenderOptions(C.QPdfDocumentRenderOptions_new2(param1.cPointer())) +} + +func (this *QPdfDocumentRenderOptions) Rotation() QPdf__Rotation { + return (QPdf__Rotation)(C.QPdfDocumentRenderOptions_rotation(this.h)) +} + +func (this *QPdfDocumentRenderOptions) SetRotation(r QPdf__Rotation) { + C.QPdfDocumentRenderOptions_setRotation(this.h, (C.int)(r)) +} + +func (this *QPdfDocumentRenderOptions) RenderFlags() QPdf__RenderFlag { + return (QPdf__RenderFlag)(C.QPdfDocumentRenderOptions_renderFlags(this.h)) +} + +func (this *QPdfDocumentRenderOptions) SetRenderFlags(r QPdf__RenderFlag) { + C.QPdfDocumentRenderOptions_setRenderFlags(this.h, (C.int)(r)) +} + +func (this *QPdfDocumentRenderOptions) ScaledClipRect() *qt.QRect { + _goptr := qt.UnsafeNewQRect(unsafe.Pointer(C.QPdfDocumentRenderOptions_scaledClipRect(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocumentRenderOptions) SetScaledClipRect(r *qt.QRect) { + C.QPdfDocumentRenderOptions_setScaledClipRect(this.h, (*C.QRect)(r.UnsafePointer())) +} + +func (this *QPdfDocumentRenderOptions) ScaledSize() *qt.QSize { + _goptr := qt.UnsafeNewQSize(unsafe.Pointer(C.QPdfDocumentRenderOptions_scaledSize(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocumentRenderOptions) SetScaledSize(s *qt.QSize) { + C.QPdfDocumentRenderOptions_setScaledSize(this.h, (*C.QSize)(s.UnsafePointer())) +} + +// Delete this object from C++ memory. +func (this *QPdfDocumentRenderOptions) Delete() { + C.QPdfDocumentRenderOptions_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfDocumentRenderOptions) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfDocumentRenderOptions) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/pdf/gen_qpdfdocumentrenderoptions.h b/qt/pdf/gen_qpdfdocumentrenderoptions.h new file mode 100644 index 00000000..52ef7ad9 --- /dev/null +++ b/qt/pdf/gen_qpdfdocumentrenderoptions.h @@ -0,0 +1,43 @@ +#pragma once +#ifndef MIQT_QT_PDF_GEN_QPDFDOCUMENTRENDEROPTIONS_H +#define MIQT_QT_PDF_GEN_QPDFDOCUMENTRENDEROPTIONS_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QPdfDocumentRenderOptions; +class QRect; +class QSize; +#else +typedef struct QPdfDocumentRenderOptions QPdfDocumentRenderOptions; +typedef struct QRect QRect; +typedef struct QSize QSize; +#endif + +QPdfDocumentRenderOptions* QPdfDocumentRenderOptions_new(); +QPdfDocumentRenderOptions* QPdfDocumentRenderOptions_new2(QPdfDocumentRenderOptions* param1); +int QPdfDocumentRenderOptions_rotation(const QPdfDocumentRenderOptions* self); +void QPdfDocumentRenderOptions_setRotation(QPdfDocumentRenderOptions* self, int r); +int QPdfDocumentRenderOptions_renderFlags(const QPdfDocumentRenderOptions* self); +void QPdfDocumentRenderOptions_setRenderFlags(QPdfDocumentRenderOptions* self, int r); +QRect* QPdfDocumentRenderOptions_scaledClipRect(const QPdfDocumentRenderOptions* self); +void QPdfDocumentRenderOptions_setScaledClipRect(QPdfDocumentRenderOptions* self, QRect* r); +QSize* QPdfDocumentRenderOptions_scaledSize(const QPdfDocumentRenderOptions* self); +void QPdfDocumentRenderOptions_setScaledSize(QPdfDocumentRenderOptions* self, QSize* s); +void QPdfDocumentRenderOptions_delete(QPdfDocumentRenderOptions* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/pdf/gen_qpdfnamespace.cpp b/qt/pdf/gen_qpdfnamespace.cpp new file mode 100644 index 00000000..08afd803 --- /dev/null +++ b/qt/pdf/gen_qpdfnamespace.cpp @@ -0,0 +1,11 @@ +#include +#include "gen_qpdfnamespace.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + diff --git a/qt/pdf/gen_qpdfnamespace.go b/qt/pdf/gen_qpdfnamespace.go new file mode 100644 index 00000000..0012f7e6 --- /dev/null +++ b/qt/pdf/gen_qpdfnamespace.go @@ -0,0 +1,31 @@ +package pdf + +/* + +#include "gen_qpdfnamespace.h" +#include + +*/ +import "C" + +type QPdf__Rotation int + +const ( + QPdf__Rotate0 QPdf__Rotation = 0 + QPdf__Rotate90 QPdf__Rotation = 1 + QPdf__Rotate180 QPdf__Rotation = 2 + QPdf__Rotate270 QPdf__Rotation = 3 +) + +type QPdf__RenderFlag int + +const ( + QPdf__NoRenderFlags QPdf__RenderFlag = 0 + QPdf__RenderAnnotations QPdf__RenderFlag = 1 + QPdf__RenderOptimizedForLcd QPdf__RenderFlag = 2 + QPdf__RenderGrayscale QPdf__RenderFlag = 4 + QPdf__RenderForceHalftone QPdf__RenderFlag = 8 + QPdf__RenderTextAliased QPdf__RenderFlag = 16 + QPdf__RenderImageAliased QPdf__RenderFlag = 32 + QPdf__RenderPathAliased QPdf__RenderFlag = 64 +) diff --git a/qt/pdf/gen_qpdfnamespace.h b/qt/pdf/gen_qpdfnamespace.h new file mode 100644 index 00000000..58826980 --- /dev/null +++ b/qt/pdf/gen_qpdfnamespace.h @@ -0,0 +1,25 @@ +#pragma once +#ifndef MIQT_QT_PDF_GEN_QPDFNAMESPACE_H +#define MIQT_QT_PDF_GEN_QPDFNAMESPACE_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +#else +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/pdf/gen_qpdfpagenavigation.cpp b/qt/pdf/gen_qpdfpagenavigation.cpp new file mode 100644 index 00000000..86b7d054 --- /dev/null +++ b/qt/pdf/gen_qpdfpagenavigation.cpp @@ -0,0 +1,530 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qpdfpagenavigation.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QPdfPageNavigation_documentChanged(intptr_t, QPdfDocument*); +void miqt_exec_callback_QPdfPageNavigation_currentPageChanged(intptr_t, int); +void miqt_exec_callback_QPdfPageNavigation_pageCountChanged(intptr_t, int); +void miqt_exec_callback_QPdfPageNavigation_canGoToPreviousPageChanged(intptr_t, bool); +void miqt_exec_callback_QPdfPageNavigation_canGoToNextPageChanged(intptr_t, bool); +bool miqt_exec_callback_QPdfPageNavigation_event(QPdfPageNavigation*, intptr_t, QEvent*); +bool miqt_exec_callback_QPdfPageNavigation_eventFilter(QPdfPageNavigation*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QPdfPageNavigation_timerEvent(QPdfPageNavigation*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QPdfPageNavigation_childEvent(QPdfPageNavigation*, intptr_t, QChildEvent*); +void miqt_exec_callback_QPdfPageNavigation_customEvent(QPdfPageNavigation*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfPageNavigation_connectNotify(QPdfPageNavigation*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QPdfPageNavigation_disconnectNotify(QPdfPageNavigation*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQPdfPageNavigation final : public QPdfPageNavigation { +public: + + MiqtVirtualQPdfPageNavigation(): QPdfPageNavigation() {}; + MiqtVirtualQPdfPageNavigation(QObject* parent): QPdfPageNavigation(parent) {}; + + virtual ~MiqtVirtualQPdfPageNavigation() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QPdfPageNavigation::event(event); + } + + QEvent* sigval1 = event; + + bool callback_return_value = miqt_exec_callback_QPdfPageNavigation_event(this, handle__event, sigval1); + + return callback_return_value; + } + + friend bool QPdfPageNavigation_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QPdfPageNavigation::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + + bool callback_return_value = miqt_exec_callback_QPdfPageNavigation_eventFilter(this, handle__eventFilter, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfPageNavigation_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__timerEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void timerEvent(QTimerEvent* event) override { + if (handle__timerEvent == 0) { + QPdfPageNavigation::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + + miqt_exec_callback_QPdfPageNavigation_timerEvent(this, handle__timerEvent, sigval1); + + + } + + friend void QPdfPageNavigation_virtualbase_timerEvent(void* self, QTimerEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__childEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void childEvent(QChildEvent* event) override { + if (handle__childEvent == 0) { + QPdfPageNavigation::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + + miqt_exec_callback_QPdfPageNavigation_childEvent(this, handle__childEvent, sigval1); + + + } + + friend void QPdfPageNavigation_virtualbase_childEvent(void* self, QChildEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__customEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void customEvent(QEvent* event) override { + if (handle__customEvent == 0) { + QPdfPageNavigation::customEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfPageNavigation_customEvent(this, handle__customEvent, sigval1); + + + } + + friend void QPdfPageNavigation_virtualbase_customEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__connectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void connectNotify(const QMetaMethod& signal) override { + if (handle__connectNotify == 0) { + QPdfPageNavigation::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfPageNavigation_connectNotify(this, handle__connectNotify, sigval1); + + + } + + friend void QPdfPageNavigation_virtualbase_connectNotify(void* self, QMetaMethod* signal); + + // cgo.Handle value for overwritten implementation + intptr_t handle__disconnectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void disconnectNotify(const QMetaMethod& signal) override { + if (handle__disconnectNotify == 0) { + QPdfPageNavigation::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfPageNavigation_disconnectNotify(this, handle__disconnectNotify, sigval1); + + + } + + friend void QPdfPageNavigation_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QPdfPageNavigation_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QPdfPageNavigation_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QPdfPageNavigation_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QPdfPageNavigation_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QPdfPageNavigation* QPdfPageNavigation_new() { + return new MiqtVirtualQPdfPageNavigation(); +} + +QPdfPageNavigation* QPdfPageNavigation_new2(QObject* parent) { + return new MiqtVirtualQPdfPageNavigation(parent); +} + +void QPdfPageNavigation_virtbase(QPdfPageNavigation* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QPdfPageNavigation_metaObject(const QPdfPageNavigation* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QPdfPageNavigation_metacast(QPdfPageNavigation* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QPdfPageNavigation_tr(const char* s) { + QString _ret = QPdfPageNavigation::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 QPdfPageNavigation_trUtf8(const char* s) { + QString _ret = QPdfPageNavigation::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; +} + +QPdfDocument* QPdfPageNavigation_document(const QPdfPageNavigation* self) { + return self->document(); +} + +void QPdfPageNavigation_setDocument(QPdfPageNavigation* self, QPdfDocument* document) { + self->setDocument(document); +} + +int QPdfPageNavigation_currentPage(const QPdfPageNavigation* self) { + return self->currentPage(); +} + +void QPdfPageNavigation_setCurrentPage(QPdfPageNavigation* self, int currentPage) { + self->setCurrentPage(static_cast(currentPage)); +} + +int QPdfPageNavigation_pageCount(const QPdfPageNavigation* self) { + return self->pageCount(); +} + +bool QPdfPageNavigation_canGoToPreviousPage(const QPdfPageNavigation* self) { + return self->canGoToPreviousPage(); +} + +bool QPdfPageNavigation_canGoToNextPage(const QPdfPageNavigation* self) { + return self->canGoToNextPage(); +} + +void QPdfPageNavigation_goToPreviousPage(QPdfPageNavigation* self) { + self->goToPreviousPage(); +} + +void QPdfPageNavigation_goToNextPage(QPdfPageNavigation* self) { + self->goToNextPage(); +} + +void QPdfPageNavigation_documentChanged(QPdfPageNavigation* self, QPdfDocument* document) { + self->documentChanged(document); +} + +void QPdfPageNavigation_connect_documentChanged(QPdfPageNavigation* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigation::connect(self, static_cast(&QPdfPageNavigation::documentChanged), self, [=](QPdfDocument* document) { + QPdfDocument* sigval1 = document; + miqt_exec_callback_QPdfPageNavigation_documentChanged(slot, sigval1); + }); +} + +void QPdfPageNavigation_currentPageChanged(QPdfPageNavigation* self, int currentPage) { + self->currentPageChanged(static_cast(currentPage)); +} + +void QPdfPageNavigation_connect_currentPageChanged(QPdfPageNavigation* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigation::connect(self, static_cast(&QPdfPageNavigation::currentPageChanged), self, [=](int currentPage) { + int sigval1 = currentPage; + miqt_exec_callback_QPdfPageNavigation_currentPageChanged(slot, sigval1); + }); +} + +void QPdfPageNavigation_pageCountChanged(QPdfPageNavigation* self, int pageCount) { + self->pageCountChanged(static_cast(pageCount)); +} + +void QPdfPageNavigation_connect_pageCountChanged(QPdfPageNavigation* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigation::connect(self, static_cast(&QPdfPageNavigation::pageCountChanged), self, [=](int pageCount) { + int sigval1 = pageCount; + miqt_exec_callback_QPdfPageNavigation_pageCountChanged(slot, sigval1); + }); +} + +void QPdfPageNavigation_canGoToPreviousPageChanged(QPdfPageNavigation* self, bool canGo) { + self->canGoToPreviousPageChanged(canGo); +} + +void QPdfPageNavigation_connect_canGoToPreviousPageChanged(QPdfPageNavigation* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigation::connect(self, static_cast(&QPdfPageNavigation::canGoToPreviousPageChanged), self, [=](bool canGo) { + bool sigval1 = canGo; + miqt_exec_callback_QPdfPageNavigation_canGoToPreviousPageChanged(slot, sigval1); + }); +} + +void QPdfPageNavigation_canGoToNextPageChanged(QPdfPageNavigation* self, bool canGo) { + self->canGoToNextPageChanged(canGo); +} + +void QPdfPageNavigation_connect_canGoToNextPageChanged(QPdfPageNavigation* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigation::connect(self, static_cast(&QPdfPageNavigation::canGoToNextPageChanged), self, [=](bool canGo) { + bool sigval1 = canGo; + miqt_exec_callback_QPdfPageNavigation_canGoToNextPageChanged(slot, sigval1); + }); +} + +struct miqt_string QPdfPageNavigation_tr2(const char* s, const char* c) { + QString _ret = QPdfPageNavigation::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 QPdfPageNavigation_tr3(const char* s, const char* c, int n) { + QString _ret = QPdfPageNavigation::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 QPdfPageNavigation_trUtf82(const char* s, const char* c) { + QString _ret = QPdfPageNavigation::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 QPdfPageNavigation_trUtf83(const char* s, const char* c, int n) { + QString _ret = QPdfPageNavigation::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; +} + +bool QPdfPageNavigation_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigation* self_cast = dynamic_cast( (QPdfPageNavigation*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QPdfPageNavigation_virtualbase_event(void* self, QEvent* event) { + + return ( (MiqtVirtualQPdfPageNavigation*)(self) )->QPdfPageNavigation::event(event); + +} + +bool QPdfPageNavigation_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigation* self_cast = dynamic_cast( (QPdfPageNavigation*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QPdfPageNavigation_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + + return ( (MiqtVirtualQPdfPageNavigation*)(self) )->QPdfPageNavigation::eventFilter(watched, event); + +} + +bool QPdfPageNavigation_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigation* self_cast = dynamic_cast( (QPdfPageNavigation*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QPdfPageNavigation_virtualbase_timerEvent(void* self, QTimerEvent* event) { + + ( (MiqtVirtualQPdfPageNavigation*)(self) )->QPdfPageNavigation::timerEvent(event); + +} + +bool QPdfPageNavigation_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigation* self_cast = dynamic_cast( (QPdfPageNavigation*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QPdfPageNavigation_virtualbase_childEvent(void* self, QChildEvent* event) { + + ( (MiqtVirtualQPdfPageNavigation*)(self) )->QPdfPageNavigation::childEvent(event); + +} + +bool QPdfPageNavigation_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigation* self_cast = dynamic_cast( (QPdfPageNavigation*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QPdfPageNavigation_virtualbase_customEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfPageNavigation*)(self) )->QPdfPageNavigation::customEvent(event); + +} + +bool QPdfPageNavigation_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigation* self_cast = dynamic_cast( (QPdfPageNavigation*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QPdfPageNavigation_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfPageNavigation*)(self) )->QPdfPageNavigation::connectNotify(*signal); + +} + +bool QPdfPageNavigation_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigation* self_cast = dynamic_cast( (QPdfPageNavigation*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QPdfPageNavigation_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfPageNavigation*)(self) )->QPdfPageNavigation::disconnectNotify(*signal); + +} + +QObject* QPdfPageNavigation_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfPageNavigation* self_cast = dynamic_cast( (QPdfPageNavigation*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return self_cast->sender(); + +} + +int QPdfPageNavigation_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfPageNavigation* self_cast = dynamic_cast( (QPdfPageNavigation*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->senderSignalIndex(); + +} + +int QPdfPageNavigation_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQPdfPageNavigation* self_cast = dynamic_cast( (QPdfPageNavigation*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->receivers(signal); + +} + +bool QPdfPageNavigation_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQPdfPageNavigation* self_cast = dynamic_cast( (QPdfPageNavigation*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->isSignalConnected(*signal); + +} + +void QPdfPageNavigation_delete(QPdfPageNavigation* self) { + delete self; +} + diff --git a/qt/pdf/gen_qpdfpagenavigation.go b/qt/pdf/gen_qpdfpagenavigation.go new file mode 100644 index 00000000..aef54356 --- /dev/null +++ b/qt/pdf/gen_qpdfpagenavigation.go @@ -0,0 +1,532 @@ +package pdf + +/* + +#include "gen_qpdfpagenavigation.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QPdfPageNavigation struct { + h *C.QPdfPageNavigation + *qt.QObject +} + +func (this *QPdfPageNavigation) cPointer() *C.QPdfPageNavigation { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfPageNavigation) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfPageNavigation constructs the type using only CGO pointers. +func newQPdfPageNavigation(h *C.QPdfPageNavigation) *QPdfPageNavigation { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QPdfPageNavigation_virtbase(h, &outptr_QObject) + + return &QPdfPageNavigation{h: h, + QObject: qt.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQPdfPageNavigation constructs the type using only unsafe pointers. +func UnsafeNewQPdfPageNavigation(h unsafe.Pointer) *QPdfPageNavigation { + return newQPdfPageNavigation((*C.QPdfPageNavigation)(h)) +} + +// NewQPdfPageNavigation constructs a new QPdfPageNavigation object. +func NewQPdfPageNavigation() *QPdfPageNavigation { + + return newQPdfPageNavigation(C.QPdfPageNavigation_new()) +} + +// NewQPdfPageNavigation2 constructs a new QPdfPageNavigation object. +func NewQPdfPageNavigation2(parent *qt.QObject) *QPdfPageNavigation { + + return newQPdfPageNavigation(C.QPdfPageNavigation_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QPdfPageNavigation) MetaObject() *qt.QMetaObject { + return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QPdfPageNavigation_metaObject(this.h))) +} + +func (this *QPdfPageNavigation) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QPdfPageNavigation_metacast(this.h, param1_Cstring)) +} + +func QPdfPageNavigation_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageNavigation_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfPageNavigation_TrUtf8(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageNavigation_trUtf8(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfPageNavigation) Document() *QPdfDocument { + return newQPdfDocument(C.QPdfPageNavigation_document(this.h)) +} + +func (this *QPdfPageNavigation) SetDocument(document *QPdfDocument) { + C.QPdfPageNavigation_setDocument(this.h, document.cPointer()) +} + +func (this *QPdfPageNavigation) CurrentPage() int { + return (int)(C.QPdfPageNavigation_currentPage(this.h)) +} + +func (this *QPdfPageNavigation) SetCurrentPage(currentPage int) { + C.QPdfPageNavigation_setCurrentPage(this.h, (C.int)(currentPage)) +} + +func (this *QPdfPageNavigation) PageCount() int { + return (int)(C.QPdfPageNavigation_pageCount(this.h)) +} + +func (this *QPdfPageNavigation) CanGoToPreviousPage() bool { + return (bool)(C.QPdfPageNavigation_canGoToPreviousPage(this.h)) +} + +func (this *QPdfPageNavigation) CanGoToNextPage() bool { + return (bool)(C.QPdfPageNavigation_canGoToNextPage(this.h)) +} + +func (this *QPdfPageNavigation) GoToPreviousPage() { + C.QPdfPageNavigation_goToPreviousPage(this.h) +} + +func (this *QPdfPageNavigation) GoToNextPage() { + C.QPdfPageNavigation_goToNextPage(this.h) +} + +func (this *QPdfPageNavigation) DocumentChanged(document *QPdfDocument) { + C.QPdfPageNavigation_documentChanged(this.h, document.cPointer()) +} +func (this *QPdfPageNavigation) OnDocumentChanged(slot func(document *QPdfDocument)) { + C.QPdfPageNavigation_connect_documentChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageNavigation_documentChanged +func miqt_exec_callback_QPdfPageNavigation_documentChanged(cb C.intptr_t, document *C.QPdfDocument) { + gofunc, ok := cgo.Handle(cb).Value().(func(document *QPdfDocument)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQPdfDocument(document) + + gofunc(slotval1) +} + +func (this *QPdfPageNavigation) CurrentPageChanged(currentPage int) { + C.QPdfPageNavigation_currentPageChanged(this.h, (C.int)(currentPage)) +} +func (this *QPdfPageNavigation) OnCurrentPageChanged(slot func(currentPage int)) { + C.QPdfPageNavigation_connect_currentPageChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageNavigation_currentPageChanged +func miqt_exec_callback_QPdfPageNavigation_currentPageChanged(cb C.intptr_t, currentPage C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(currentPage int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(currentPage) + + gofunc(slotval1) +} + +func (this *QPdfPageNavigation) PageCountChanged(pageCount int) { + C.QPdfPageNavigation_pageCountChanged(this.h, (C.int)(pageCount)) +} +func (this *QPdfPageNavigation) OnPageCountChanged(slot func(pageCount int)) { + C.QPdfPageNavigation_connect_pageCountChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageNavigation_pageCountChanged +func miqt_exec_callback_QPdfPageNavigation_pageCountChanged(cb C.intptr_t, pageCount C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(pageCount int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(pageCount) + + gofunc(slotval1) +} + +func (this *QPdfPageNavigation) CanGoToPreviousPageChanged(canGo bool) { + C.QPdfPageNavigation_canGoToPreviousPageChanged(this.h, (C.bool)(canGo)) +} +func (this *QPdfPageNavigation) OnCanGoToPreviousPageChanged(slot func(canGo bool)) { + C.QPdfPageNavigation_connect_canGoToPreviousPageChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageNavigation_canGoToPreviousPageChanged +func miqt_exec_callback_QPdfPageNavigation_canGoToPreviousPageChanged(cb C.intptr_t, canGo C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(canGo bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(canGo) + + gofunc(slotval1) +} + +func (this *QPdfPageNavigation) CanGoToNextPageChanged(canGo bool) { + C.QPdfPageNavigation_canGoToNextPageChanged(this.h, (C.bool)(canGo)) +} +func (this *QPdfPageNavigation) OnCanGoToNextPageChanged(slot func(canGo bool)) { + C.QPdfPageNavigation_connect_canGoToNextPageChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageNavigation_canGoToNextPageChanged +func miqt_exec_callback_QPdfPageNavigation_canGoToNextPageChanged(cb C.intptr_t, canGo C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(canGo bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(canGo) + + gofunc(slotval1) +} + +func QPdfPageNavigation_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageNavigation_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfPageNavigation_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageNavigation_tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfPageNavigation_TrUtf82(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageNavigation_trUtf82(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfPageNavigation_TrUtf83(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageNavigation_trUtf83(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +// Sender can only be called from a QPdfPageNavigation that was directly constructed. +func (this *QPdfPageNavigation) Sender() *qt.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt.UnsafeNewQObject(unsafe.Pointer(C.QPdfPageNavigation_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// SenderSignalIndex can only be called from a QPdfPageNavigation that was directly constructed. +func (this *QPdfPageNavigation) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfPageNavigation_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Receivers can only be called from a QPdfPageNavigation that was directly constructed. +func (this *QPdfPageNavigation) Receivers(signal string) int { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfPageNavigation_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// IsSignalConnected can only be called from a QPdfPageNavigation that was directly constructed. +func (this *QPdfPageNavigation) IsSignalConnected(signal *qt.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfPageNavigation_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +func (this *QPdfPageNavigation) callVirtualBase_Event(event *qt.QEvent) bool { + + return (bool)(C.QPdfPageNavigation_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfPageNavigation) OnEvent(slot func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) { + ok := C.QPdfPageNavigation_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigation_event +func miqt_exec_callback_QPdfPageNavigation_event(self *C.QPdfPageNavigation, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfPageNavigation{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfPageNavigation) callVirtualBase_EventFilter(watched *qt.QObject, event *qt.QEvent) bool { + + return (bool)(C.QPdfPageNavigation_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfPageNavigation) OnEventFilter(slot func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) { + ok := C.QPdfPageNavigation_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigation_eventFilter +func miqt_exec_callback_QPdfPageNavigation_eventFilter(self *C.QPdfPageNavigation, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfPageNavigation{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfPageNavigation) callVirtualBase_TimerEvent(event *qt.QTimerEvent) { + + C.QPdfPageNavigation_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QPdfPageNavigation) OnTimerEvent(slot func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) { + ok := C.QPdfPageNavigation_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigation_timerEvent +func miqt_exec_callback_QPdfPageNavigation_timerEvent(self *C.QPdfPageNavigation, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QPdfPageNavigation{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QPdfPageNavigation) callVirtualBase_ChildEvent(event *qt.QChildEvent) { + + C.QPdfPageNavigation_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QPdfPageNavigation) OnChildEvent(slot func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) { + ok := C.QPdfPageNavigation_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigation_childEvent +func miqt_exec_callback_QPdfPageNavigation_childEvent(self *C.QPdfPageNavigation, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QPdfPageNavigation{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QPdfPageNavigation) callVirtualBase_CustomEvent(event *qt.QEvent) { + + C.QPdfPageNavigation_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfPageNavigation) OnCustomEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) { + ok := C.QPdfPageNavigation_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigation_customEvent +func miqt_exec_callback_QPdfPageNavigation_customEvent(self *C.QPdfPageNavigation, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfPageNavigation{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QPdfPageNavigation) callVirtualBase_ConnectNotify(signal *qt.QMetaMethod) { + + C.QPdfPageNavigation_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfPageNavigation) OnConnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QPdfPageNavigation_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigation_connectNotify +func miqt_exec_callback_QPdfPageNavigation_connectNotify(self *C.QPdfPageNavigation, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfPageNavigation{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QPdfPageNavigation) callVirtualBase_DisconnectNotify(signal *qt.QMetaMethod) { + + C.QPdfPageNavigation_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfPageNavigation) OnDisconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QPdfPageNavigation_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigation_disconnectNotify +func miqt_exec_callback_QPdfPageNavigation_disconnectNotify(self *C.QPdfPageNavigation, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfPageNavigation{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QPdfPageNavigation) Delete() { + C.QPdfPageNavigation_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfPageNavigation) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfPageNavigation) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/pdf/gen_qpdfpagenavigation.h b/qt/pdf/gen_qpdfpagenavigation.h new file mode 100644 index 00000000..31480811 --- /dev/null +++ b/qt/pdf/gen_qpdfpagenavigation.h @@ -0,0 +1,91 @@ +#pragma once +#ifndef MIQT_QT_PDF_GEN_QPDFPAGENAVIGATION_H +#define MIQT_QT_PDF_GEN_QPDFPAGENAVIGATION_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QChildEvent; +class QEvent; +class QMetaMethod; +class QMetaObject; +class QObject; +class QPdfDocument; +class QPdfPageNavigation; +class QTimerEvent; +#else +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QPdfDocument QPdfDocument; +typedef struct QPdfPageNavigation QPdfPageNavigation; +typedef struct QTimerEvent QTimerEvent; +#endif + +QPdfPageNavigation* QPdfPageNavigation_new(); +QPdfPageNavigation* QPdfPageNavigation_new2(QObject* parent); +void QPdfPageNavigation_virtbase(QPdfPageNavigation* src, QObject** outptr_QObject); +QMetaObject* QPdfPageNavigation_metaObject(const QPdfPageNavigation* self); +void* QPdfPageNavigation_metacast(QPdfPageNavigation* self, const char* param1); +struct miqt_string QPdfPageNavigation_tr(const char* s); +struct miqt_string QPdfPageNavigation_trUtf8(const char* s); +QPdfDocument* QPdfPageNavigation_document(const QPdfPageNavigation* self); +void QPdfPageNavigation_setDocument(QPdfPageNavigation* self, QPdfDocument* document); +int QPdfPageNavigation_currentPage(const QPdfPageNavigation* self); +void QPdfPageNavigation_setCurrentPage(QPdfPageNavigation* self, int currentPage); +int QPdfPageNavigation_pageCount(const QPdfPageNavigation* self); +bool QPdfPageNavigation_canGoToPreviousPage(const QPdfPageNavigation* self); +bool QPdfPageNavigation_canGoToNextPage(const QPdfPageNavigation* self); +void QPdfPageNavigation_goToPreviousPage(QPdfPageNavigation* self); +void QPdfPageNavigation_goToNextPage(QPdfPageNavigation* self); +void QPdfPageNavigation_documentChanged(QPdfPageNavigation* self, QPdfDocument* document); +void QPdfPageNavigation_connect_documentChanged(QPdfPageNavigation* self, intptr_t slot); +void QPdfPageNavigation_currentPageChanged(QPdfPageNavigation* self, int currentPage); +void QPdfPageNavigation_connect_currentPageChanged(QPdfPageNavigation* self, intptr_t slot); +void QPdfPageNavigation_pageCountChanged(QPdfPageNavigation* self, int pageCount); +void QPdfPageNavigation_connect_pageCountChanged(QPdfPageNavigation* self, intptr_t slot); +void QPdfPageNavigation_canGoToPreviousPageChanged(QPdfPageNavigation* self, bool canGo); +void QPdfPageNavigation_connect_canGoToPreviousPageChanged(QPdfPageNavigation* self, intptr_t slot); +void QPdfPageNavigation_canGoToNextPageChanged(QPdfPageNavigation* self, bool canGo); +void QPdfPageNavigation_connect_canGoToNextPageChanged(QPdfPageNavigation* self, intptr_t slot); +struct miqt_string QPdfPageNavigation_tr2(const char* s, const char* c); +struct miqt_string QPdfPageNavigation_tr3(const char* s, const char* c, int n); +struct miqt_string QPdfPageNavigation_trUtf82(const char* s, const char* c); +struct miqt_string QPdfPageNavigation_trUtf83(const char* s, const char* c, int n); +bool QPdfPageNavigation_override_virtual_event(void* self, intptr_t slot); +bool QPdfPageNavigation_virtualbase_event(void* self, QEvent* event); +bool QPdfPageNavigation_override_virtual_eventFilter(void* self, intptr_t slot); +bool QPdfPageNavigation_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QPdfPageNavigation_override_virtual_timerEvent(void* self, intptr_t slot); +void QPdfPageNavigation_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QPdfPageNavigation_override_virtual_childEvent(void* self, intptr_t slot); +void QPdfPageNavigation_virtualbase_childEvent(void* self, QChildEvent* event); +bool QPdfPageNavigation_override_virtual_customEvent(void* self, intptr_t slot); +void QPdfPageNavigation_virtualbase_customEvent(void* self, QEvent* event); +bool QPdfPageNavigation_override_virtual_connectNotify(void* self, intptr_t slot); +void QPdfPageNavigation_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QPdfPageNavigation_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QPdfPageNavigation_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); +QObject* QPdfPageNavigation_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QPdfPageNavigation_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QPdfPageNavigation_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QPdfPageNavigation_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +void QPdfPageNavigation_delete(QPdfPageNavigation* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/pdf/gen_qpdfpagerenderer.cpp b/qt/pdf/gen_qpdfpagerenderer.cpp new file mode 100644 index 00000000..52db6310 --- /dev/null +++ b/qt/pdf/gen_qpdfpagerenderer.cpp @@ -0,0 +1,508 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qpdfpagerenderer.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QPdfPageRenderer_documentChanged(intptr_t, QPdfDocument*); +void miqt_exec_callback_QPdfPageRenderer_renderModeChanged(intptr_t, int); +void miqt_exec_callback_QPdfPageRenderer_pageRendered(intptr_t, int, QSize*, QImage*, QPdfDocumentRenderOptions*, unsigned long long); +bool miqt_exec_callback_QPdfPageRenderer_event(QPdfPageRenderer*, intptr_t, QEvent*); +bool miqt_exec_callback_QPdfPageRenderer_eventFilter(QPdfPageRenderer*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QPdfPageRenderer_timerEvent(QPdfPageRenderer*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QPdfPageRenderer_childEvent(QPdfPageRenderer*, intptr_t, QChildEvent*); +void miqt_exec_callback_QPdfPageRenderer_customEvent(QPdfPageRenderer*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfPageRenderer_connectNotify(QPdfPageRenderer*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QPdfPageRenderer_disconnectNotify(QPdfPageRenderer*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQPdfPageRenderer final : public QPdfPageRenderer { +public: + + MiqtVirtualQPdfPageRenderer(): QPdfPageRenderer() {}; + MiqtVirtualQPdfPageRenderer(QObject* parent): QPdfPageRenderer(parent) {}; + + virtual ~MiqtVirtualQPdfPageRenderer() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QPdfPageRenderer::event(event); + } + + QEvent* sigval1 = event; + + bool callback_return_value = miqt_exec_callback_QPdfPageRenderer_event(this, handle__event, sigval1); + + return callback_return_value; + } + + friend bool QPdfPageRenderer_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QPdfPageRenderer::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + + bool callback_return_value = miqt_exec_callback_QPdfPageRenderer_eventFilter(this, handle__eventFilter, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfPageRenderer_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__timerEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void timerEvent(QTimerEvent* event) override { + if (handle__timerEvent == 0) { + QPdfPageRenderer::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + + miqt_exec_callback_QPdfPageRenderer_timerEvent(this, handle__timerEvent, sigval1); + + + } + + friend void QPdfPageRenderer_virtualbase_timerEvent(void* self, QTimerEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__childEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void childEvent(QChildEvent* event) override { + if (handle__childEvent == 0) { + QPdfPageRenderer::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + + miqt_exec_callback_QPdfPageRenderer_childEvent(this, handle__childEvent, sigval1); + + + } + + friend void QPdfPageRenderer_virtualbase_childEvent(void* self, QChildEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__customEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void customEvent(QEvent* event) override { + if (handle__customEvent == 0) { + QPdfPageRenderer::customEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfPageRenderer_customEvent(this, handle__customEvent, sigval1); + + + } + + friend void QPdfPageRenderer_virtualbase_customEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__connectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void connectNotify(const QMetaMethod& signal) override { + if (handle__connectNotify == 0) { + QPdfPageRenderer::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfPageRenderer_connectNotify(this, handle__connectNotify, sigval1); + + + } + + friend void QPdfPageRenderer_virtualbase_connectNotify(void* self, QMetaMethod* signal); + + // cgo.Handle value for overwritten implementation + intptr_t handle__disconnectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void disconnectNotify(const QMetaMethod& signal) override { + if (handle__disconnectNotify == 0) { + QPdfPageRenderer::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfPageRenderer_disconnectNotify(this, handle__disconnectNotify, sigval1); + + + } + + friend void QPdfPageRenderer_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QPdfPageRenderer_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QPdfPageRenderer_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QPdfPageRenderer_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QPdfPageRenderer_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QPdfPageRenderer* QPdfPageRenderer_new() { + return new MiqtVirtualQPdfPageRenderer(); +} + +QPdfPageRenderer* QPdfPageRenderer_new2(QObject* parent) { + return new MiqtVirtualQPdfPageRenderer(parent); +} + +void QPdfPageRenderer_virtbase(QPdfPageRenderer* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QPdfPageRenderer_metaObject(const QPdfPageRenderer* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QPdfPageRenderer_metacast(QPdfPageRenderer* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QPdfPageRenderer_tr(const char* s) { + QString _ret = QPdfPageRenderer::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 QPdfPageRenderer_trUtf8(const char* s) { + QString _ret = QPdfPageRenderer::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; +} + +int QPdfPageRenderer_renderMode(const QPdfPageRenderer* self) { + QPdfPageRenderer::RenderMode _ret = self->renderMode(); + return static_cast(_ret); +} + +void QPdfPageRenderer_setRenderMode(QPdfPageRenderer* self, int mode) { + self->setRenderMode(static_cast(mode)); +} + +QPdfDocument* QPdfPageRenderer_document(const QPdfPageRenderer* self) { + return self->document(); +} + +void QPdfPageRenderer_setDocument(QPdfPageRenderer* self, QPdfDocument* document) { + self->setDocument(document); +} + +unsigned long long QPdfPageRenderer_requestPage(QPdfPageRenderer* self, int pageNumber, QSize* imageSize) { + quint64 _ret = self->requestPage(static_cast(pageNumber), *imageSize); + return static_cast(_ret); +} + +void QPdfPageRenderer_documentChanged(QPdfPageRenderer* self, QPdfDocument* document) { + self->documentChanged(document); +} + +void QPdfPageRenderer_connect_documentChanged(QPdfPageRenderer* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer::connect(self, static_cast(&QPdfPageRenderer::documentChanged), self, [=](QPdfDocument* document) { + QPdfDocument* sigval1 = document; + miqt_exec_callback_QPdfPageRenderer_documentChanged(slot, sigval1); + }); +} + +void QPdfPageRenderer_renderModeChanged(QPdfPageRenderer* self, int renderMode) { + self->renderModeChanged(static_cast(renderMode)); +} + +void QPdfPageRenderer_connect_renderModeChanged(QPdfPageRenderer* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer::connect(self, static_cast(&QPdfPageRenderer::renderModeChanged), self, [=](QPdfPageRenderer::RenderMode renderMode) { + QPdfPageRenderer::RenderMode renderMode_ret = renderMode; + int sigval1 = static_cast(renderMode_ret); + miqt_exec_callback_QPdfPageRenderer_renderModeChanged(slot, sigval1); + }); +} + +void QPdfPageRenderer_pageRendered(QPdfPageRenderer* self, int pageNumber, QSize* imageSize, QImage* image, QPdfDocumentRenderOptions* options, unsigned long long requestId) { + self->pageRendered(static_cast(pageNumber), *imageSize, *image, *options, static_cast(requestId)); +} + +void QPdfPageRenderer_connect_pageRendered(QPdfPageRenderer* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer::connect(self, static_cast(&QPdfPageRenderer::pageRendered), self, [=](int pageNumber, QSize imageSize, const QImage& image, QPdfDocumentRenderOptions options, quint64 requestId) { + int sigval1 = pageNumber; + QSize* sigval2 = new QSize(imageSize); + const QImage& image_ret = image; + // Cast returned reference into pointer + QImage* sigval3 = const_cast(&image_ret); + QPdfDocumentRenderOptions* sigval4 = new QPdfDocumentRenderOptions(options); + quint64 requestId_ret = requestId; + unsigned long long sigval5 = static_cast(requestId_ret); + miqt_exec_callback_QPdfPageRenderer_pageRendered(slot, sigval1, sigval2, sigval3, sigval4, sigval5); + }); +} + +struct miqt_string QPdfPageRenderer_tr2(const char* s, const char* c) { + QString _ret = QPdfPageRenderer::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 QPdfPageRenderer_tr3(const char* s, const char* c, int n) { + QString _ret = QPdfPageRenderer::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 QPdfPageRenderer_trUtf82(const char* s, const char* c) { + QString _ret = QPdfPageRenderer::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 QPdfPageRenderer_trUtf83(const char* s, const char* c, int n) { + QString _ret = QPdfPageRenderer::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; +} + +unsigned long long QPdfPageRenderer_requestPage2(QPdfPageRenderer* self, int pageNumber, QSize* imageSize, QPdfDocumentRenderOptions* options) { + quint64 _ret = self->requestPage(static_cast(pageNumber), *imageSize, *options); + return static_cast(_ret); +} + +bool QPdfPageRenderer_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QPdfPageRenderer_virtualbase_event(void* self, QEvent* event) { + + return ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::event(event); + +} + +bool QPdfPageRenderer_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QPdfPageRenderer_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + + return ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::eventFilter(watched, event); + +} + +bool QPdfPageRenderer_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QPdfPageRenderer_virtualbase_timerEvent(void* self, QTimerEvent* event) { + + ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::timerEvent(event); + +} + +bool QPdfPageRenderer_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QPdfPageRenderer_virtualbase_childEvent(void* self, QChildEvent* event) { + + ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::childEvent(event); + +} + +bool QPdfPageRenderer_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QPdfPageRenderer_virtualbase_customEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::customEvent(event); + +} + +bool QPdfPageRenderer_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QPdfPageRenderer_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::connectNotify(*signal); + +} + +bool QPdfPageRenderer_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QPdfPageRenderer_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::disconnectNotify(*signal); + +} + +QObject* QPdfPageRenderer_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return self_cast->sender(); + +} + +int QPdfPageRenderer_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->senderSignalIndex(); + +} + +int QPdfPageRenderer_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->receivers(signal); + +} + +bool QPdfPageRenderer_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->isSignalConnected(*signal); + +} + +void QPdfPageRenderer_delete(QPdfPageRenderer* self) { + delete self; +} + diff --git a/qt/pdf/gen_qpdfpagerenderer.go b/qt/pdf/gen_qpdfpagerenderer.go new file mode 100644 index 00000000..b67cb490 --- /dev/null +++ b/qt/pdf/gen_qpdfpagerenderer.go @@ -0,0 +1,499 @@ +package pdf + +/* + +#include "gen_qpdfpagerenderer.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QPdfPageRenderer__RenderMode int + +const ( + QPdfPageRenderer__MultiThreaded QPdfPageRenderer__RenderMode = 0 + QPdfPageRenderer__SingleThreaded QPdfPageRenderer__RenderMode = 1 +) + +type QPdfPageRenderer struct { + h *C.QPdfPageRenderer + *qt.QObject +} + +func (this *QPdfPageRenderer) cPointer() *C.QPdfPageRenderer { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfPageRenderer) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfPageRenderer constructs the type using only CGO pointers. +func newQPdfPageRenderer(h *C.QPdfPageRenderer) *QPdfPageRenderer { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QPdfPageRenderer_virtbase(h, &outptr_QObject) + + return &QPdfPageRenderer{h: h, + QObject: qt.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQPdfPageRenderer constructs the type using only unsafe pointers. +func UnsafeNewQPdfPageRenderer(h unsafe.Pointer) *QPdfPageRenderer { + return newQPdfPageRenderer((*C.QPdfPageRenderer)(h)) +} + +// NewQPdfPageRenderer constructs a new QPdfPageRenderer object. +func NewQPdfPageRenderer() *QPdfPageRenderer { + + return newQPdfPageRenderer(C.QPdfPageRenderer_new()) +} + +// NewQPdfPageRenderer2 constructs a new QPdfPageRenderer object. +func NewQPdfPageRenderer2(parent *qt.QObject) *QPdfPageRenderer { + + return newQPdfPageRenderer(C.QPdfPageRenderer_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QPdfPageRenderer) MetaObject() *qt.QMetaObject { + return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QPdfPageRenderer_metaObject(this.h))) +} + +func (this *QPdfPageRenderer) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QPdfPageRenderer_metacast(this.h, param1_Cstring)) +} + +func QPdfPageRenderer_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageRenderer_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfPageRenderer_TrUtf8(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageRenderer_trUtf8(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfPageRenderer) RenderMode() QPdfPageRenderer__RenderMode { + return (QPdfPageRenderer__RenderMode)(C.QPdfPageRenderer_renderMode(this.h)) +} + +func (this *QPdfPageRenderer) SetRenderMode(mode QPdfPageRenderer__RenderMode) { + C.QPdfPageRenderer_setRenderMode(this.h, (C.int)(mode)) +} + +func (this *QPdfPageRenderer) Document() *QPdfDocument { + return newQPdfDocument(C.QPdfPageRenderer_document(this.h)) +} + +func (this *QPdfPageRenderer) SetDocument(document *QPdfDocument) { + C.QPdfPageRenderer_setDocument(this.h, document.cPointer()) +} + +func (this *QPdfPageRenderer) RequestPage(pageNumber int, imageSize qt.QSize) uint64 { + return (uint64)(C.QPdfPageRenderer_requestPage(this.h, (C.int)(pageNumber), (*C.QSize)(imageSize.UnsafePointer()))) +} + +func (this *QPdfPageRenderer) DocumentChanged(document *QPdfDocument) { + C.QPdfPageRenderer_documentChanged(this.h, document.cPointer()) +} +func (this *QPdfPageRenderer) OnDocumentChanged(slot func(document *QPdfDocument)) { + C.QPdfPageRenderer_connect_documentChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageRenderer_documentChanged +func miqt_exec_callback_QPdfPageRenderer_documentChanged(cb C.intptr_t, document *C.QPdfDocument) { + gofunc, ok := cgo.Handle(cb).Value().(func(document *QPdfDocument)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQPdfDocument(document) + + gofunc(slotval1) +} + +func (this *QPdfPageRenderer) RenderModeChanged(renderMode QPdfPageRenderer__RenderMode) { + C.QPdfPageRenderer_renderModeChanged(this.h, (C.int)(renderMode)) +} +func (this *QPdfPageRenderer) OnRenderModeChanged(slot func(renderMode QPdfPageRenderer__RenderMode)) { + C.QPdfPageRenderer_connect_renderModeChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageRenderer_renderModeChanged +func miqt_exec_callback_QPdfPageRenderer_renderModeChanged(cb C.intptr_t, renderMode C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(renderMode QPdfPageRenderer__RenderMode)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (QPdfPageRenderer__RenderMode)(renderMode) + + gofunc(slotval1) +} + +func (this *QPdfPageRenderer) PageRendered(pageNumber int, imageSize qt.QSize, image *qt.QImage, options QPdfDocumentRenderOptions, requestId uint64) { + C.QPdfPageRenderer_pageRendered(this.h, (C.int)(pageNumber), (*C.QSize)(imageSize.UnsafePointer()), (*C.QImage)(image.UnsafePointer()), options.cPointer(), (C.ulonglong)(requestId)) +} +func (this *QPdfPageRenderer) OnPageRendered(slot func(pageNumber int, imageSize qt.QSize, image *qt.QImage, options QPdfDocumentRenderOptions, requestId uint64)) { + C.QPdfPageRenderer_connect_pageRendered(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageRenderer_pageRendered +func miqt_exec_callback_QPdfPageRenderer_pageRendered(cb C.intptr_t, pageNumber C.int, imageSize *C.QSize, image *C.QImage, options *C.QPdfDocumentRenderOptions, requestId C.ulonglong) { + gofunc, ok := cgo.Handle(cb).Value().(func(pageNumber int, imageSize qt.QSize, image *qt.QImage, options QPdfDocumentRenderOptions, requestId uint64)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(pageNumber) + + imageSize_goptr := qt.UnsafeNewQSize(unsafe.Pointer(imageSize)) + imageSize_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + slotval2 := *imageSize_goptr + + slotval3 := qt.UnsafeNewQImage(unsafe.Pointer(image)) + + options_goptr := newQPdfDocumentRenderOptions(options) + options_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + slotval4 := *options_goptr + + slotval5 := (uint64)(requestId) + + gofunc(slotval1, slotval2, slotval3, slotval4, slotval5) +} + +func QPdfPageRenderer_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageRenderer_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfPageRenderer_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageRenderer_tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfPageRenderer_TrUtf82(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageRenderer_trUtf82(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfPageRenderer_TrUtf83(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageRenderer_trUtf83(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfPageRenderer) RequestPage2(pageNumber int, imageSize qt.QSize, options QPdfDocumentRenderOptions) uint64 { + return (uint64)(C.QPdfPageRenderer_requestPage2(this.h, (C.int)(pageNumber), (*C.QSize)(imageSize.UnsafePointer()), options.cPointer())) +} + +// Sender can only be called from a QPdfPageRenderer that was directly constructed. +func (this *QPdfPageRenderer) Sender() *qt.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt.UnsafeNewQObject(unsafe.Pointer(C.QPdfPageRenderer_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// SenderSignalIndex can only be called from a QPdfPageRenderer that was directly constructed. +func (this *QPdfPageRenderer) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfPageRenderer_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Receivers can only be called from a QPdfPageRenderer that was directly constructed. +func (this *QPdfPageRenderer) Receivers(signal string) int { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfPageRenderer_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// IsSignalConnected can only be called from a QPdfPageRenderer that was directly constructed. +func (this *QPdfPageRenderer) IsSignalConnected(signal *qt.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfPageRenderer_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +func (this *QPdfPageRenderer) callVirtualBase_Event(event *qt.QEvent) bool { + + return (bool)(C.QPdfPageRenderer_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfPageRenderer) OnEvent(slot func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) { + ok := C.QPdfPageRenderer_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_event +func miqt_exec_callback_QPdfPageRenderer_event(self *C.QPdfPageRenderer, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfPageRenderer) callVirtualBase_EventFilter(watched *qt.QObject, event *qt.QEvent) bool { + + return (bool)(C.QPdfPageRenderer_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfPageRenderer) OnEventFilter(slot func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) { + ok := C.QPdfPageRenderer_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_eventFilter +func miqt_exec_callback_QPdfPageRenderer_eventFilter(self *C.QPdfPageRenderer, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfPageRenderer) callVirtualBase_TimerEvent(event *qt.QTimerEvent) { + + C.QPdfPageRenderer_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QPdfPageRenderer) OnTimerEvent(slot func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) { + ok := C.QPdfPageRenderer_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_timerEvent +func miqt_exec_callback_QPdfPageRenderer_timerEvent(self *C.QPdfPageRenderer, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QPdfPageRenderer) callVirtualBase_ChildEvent(event *qt.QChildEvent) { + + C.QPdfPageRenderer_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QPdfPageRenderer) OnChildEvent(slot func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) { + ok := C.QPdfPageRenderer_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_childEvent +func miqt_exec_callback_QPdfPageRenderer_childEvent(self *C.QPdfPageRenderer, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QPdfPageRenderer) callVirtualBase_CustomEvent(event *qt.QEvent) { + + C.QPdfPageRenderer_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfPageRenderer) OnCustomEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) { + ok := C.QPdfPageRenderer_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_customEvent +func miqt_exec_callback_QPdfPageRenderer_customEvent(self *C.QPdfPageRenderer, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QPdfPageRenderer) callVirtualBase_ConnectNotify(signal *qt.QMetaMethod) { + + C.QPdfPageRenderer_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfPageRenderer) OnConnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QPdfPageRenderer_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_connectNotify +func miqt_exec_callback_QPdfPageRenderer_connectNotify(self *C.QPdfPageRenderer, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QPdfPageRenderer) callVirtualBase_DisconnectNotify(signal *qt.QMetaMethod) { + + C.QPdfPageRenderer_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfPageRenderer) OnDisconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QPdfPageRenderer_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_disconnectNotify +func miqt_exec_callback_QPdfPageRenderer_disconnectNotify(self *C.QPdfPageRenderer, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QPdfPageRenderer) Delete() { + C.QPdfPageRenderer_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfPageRenderer) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfPageRenderer) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/pdf/gen_qpdfpagerenderer.h b/qt/pdf/gen_qpdfpagerenderer.h new file mode 100644 index 00000000..85b1fa0d --- /dev/null +++ b/qt/pdf/gen_qpdfpagerenderer.h @@ -0,0 +1,90 @@ +#pragma once +#ifndef MIQT_QT_PDF_GEN_QPDFPAGERENDERER_H +#define MIQT_QT_PDF_GEN_QPDFPAGERENDERER_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QChildEvent; +class QEvent; +class QImage; +class QMetaMethod; +class QMetaObject; +class QObject; +class QPdfDocument; +class QPdfDocumentRenderOptions; +class QPdfPageRenderer; +class QSize; +class QTimerEvent; +#else +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QImage QImage; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QPdfDocument QPdfDocument; +typedef struct QPdfDocumentRenderOptions QPdfDocumentRenderOptions; +typedef struct QPdfPageRenderer QPdfPageRenderer; +typedef struct QSize QSize; +typedef struct QTimerEvent QTimerEvent; +#endif + +QPdfPageRenderer* QPdfPageRenderer_new(); +QPdfPageRenderer* QPdfPageRenderer_new2(QObject* parent); +void QPdfPageRenderer_virtbase(QPdfPageRenderer* src, QObject** outptr_QObject); +QMetaObject* QPdfPageRenderer_metaObject(const QPdfPageRenderer* self); +void* QPdfPageRenderer_metacast(QPdfPageRenderer* self, const char* param1); +struct miqt_string QPdfPageRenderer_tr(const char* s); +struct miqt_string QPdfPageRenderer_trUtf8(const char* s); +int QPdfPageRenderer_renderMode(const QPdfPageRenderer* self); +void QPdfPageRenderer_setRenderMode(QPdfPageRenderer* self, int mode); +QPdfDocument* QPdfPageRenderer_document(const QPdfPageRenderer* self); +void QPdfPageRenderer_setDocument(QPdfPageRenderer* self, QPdfDocument* document); +unsigned long long QPdfPageRenderer_requestPage(QPdfPageRenderer* self, int pageNumber, QSize* imageSize); +void QPdfPageRenderer_documentChanged(QPdfPageRenderer* self, QPdfDocument* document); +void QPdfPageRenderer_connect_documentChanged(QPdfPageRenderer* self, intptr_t slot); +void QPdfPageRenderer_renderModeChanged(QPdfPageRenderer* self, int renderMode); +void QPdfPageRenderer_connect_renderModeChanged(QPdfPageRenderer* self, intptr_t slot); +void QPdfPageRenderer_pageRendered(QPdfPageRenderer* self, int pageNumber, QSize* imageSize, QImage* image, QPdfDocumentRenderOptions* options, unsigned long long requestId); +void QPdfPageRenderer_connect_pageRendered(QPdfPageRenderer* self, intptr_t slot); +struct miqt_string QPdfPageRenderer_tr2(const char* s, const char* c); +struct miqt_string QPdfPageRenderer_tr3(const char* s, const char* c, int n); +struct miqt_string QPdfPageRenderer_trUtf82(const char* s, const char* c); +struct miqt_string QPdfPageRenderer_trUtf83(const char* s, const char* c, int n); +unsigned long long QPdfPageRenderer_requestPage2(QPdfPageRenderer* self, int pageNumber, QSize* imageSize, QPdfDocumentRenderOptions* options); +bool QPdfPageRenderer_override_virtual_event(void* self, intptr_t slot); +bool QPdfPageRenderer_virtualbase_event(void* self, QEvent* event); +bool QPdfPageRenderer_override_virtual_eventFilter(void* self, intptr_t slot); +bool QPdfPageRenderer_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QPdfPageRenderer_override_virtual_timerEvent(void* self, intptr_t slot); +void QPdfPageRenderer_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QPdfPageRenderer_override_virtual_childEvent(void* self, intptr_t slot); +void QPdfPageRenderer_virtualbase_childEvent(void* self, QChildEvent* event); +bool QPdfPageRenderer_override_virtual_customEvent(void* self, intptr_t slot); +void QPdfPageRenderer_virtualbase_customEvent(void* self, QEvent* event); +bool QPdfPageRenderer_override_virtual_connectNotify(void* self, intptr_t slot); +void QPdfPageRenderer_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QPdfPageRenderer_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QPdfPageRenderer_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); +QObject* QPdfPageRenderer_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QPdfPageRenderer_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QPdfPageRenderer_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QPdfPageRenderer_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +void QPdfPageRenderer_delete(QPdfPageRenderer* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/pdf/gen_qpdfsearchmodel.cpp b/qt/pdf/gen_qpdfsearchmodel.cpp new file mode 100644 index 00000000..21461c0b --- /dev/null +++ b/qt/pdf/gen_qpdfsearchmodel.cpp @@ -0,0 +1,2181 @@ +#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_qpdfsearchmodel.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QPdfSearchModel_documentChanged(intptr_t); +void miqt_exec_callback_QPdfSearchModel_searchStringChanged(intptr_t); +struct miqt_map /* of int to struct miqt_string */ miqt_exec_callback_QPdfSearchModel_roleNames(const QPdfSearchModel*, intptr_t); +int miqt_exec_callback_QPdfSearchModel_rowCount(const QPdfSearchModel*, intptr_t, QModelIndex*); +QVariant* miqt_exec_callback_QPdfSearchModel_data(const QPdfSearchModel*, intptr_t, QModelIndex*, int); +void miqt_exec_callback_QPdfSearchModel_timerEvent(QPdfSearchModel*, intptr_t, QTimerEvent*); +QModelIndex* miqt_exec_callback_QPdfSearchModel_index(const QPdfSearchModel*, intptr_t, int, int, QModelIndex*); +QModelIndex* miqt_exec_callback_QPdfSearchModel_sibling(const QPdfSearchModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_dropMimeData(QPdfSearchModel*, intptr_t, QMimeData*, int, int, int, QModelIndex*); +int miqt_exec_callback_QPdfSearchModel_flags(const QPdfSearchModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_setData(QPdfSearchModel*, intptr_t, QModelIndex*, QVariant*, int); +QVariant* miqt_exec_callback_QPdfSearchModel_headerData(const QPdfSearchModel*, intptr_t, int, int, int); +bool miqt_exec_callback_QPdfSearchModel_setHeaderData(QPdfSearchModel*, intptr_t, int, int, QVariant*, int); +struct miqt_map /* of int to QVariant* */ miqt_exec_callback_QPdfSearchModel_itemData(const QPdfSearchModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_setItemData(QPdfSearchModel*, intptr_t, QModelIndex*, struct miqt_map /* of int to QVariant* */ ); +struct miqt_array /* of struct miqt_string */ miqt_exec_callback_QPdfSearchModel_mimeTypes(const QPdfSearchModel*, intptr_t); +QMimeData* miqt_exec_callback_QPdfSearchModel_mimeData(const QPdfSearchModel*, intptr_t, struct miqt_array /* of QModelIndex* */ ); +bool miqt_exec_callback_QPdfSearchModel_canDropMimeData(const QPdfSearchModel*, intptr_t, QMimeData*, int, int, int, QModelIndex*); +int miqt_exec_callback_QPdfSearchModel_supportedDropActions(const QPdfSearchModel*, intptr_t); +int miqt_exec_callback_QPdfSearchModel_supportedDragActions(const QPdfSearchModel*, intptr_t); +bool miqt_exec_callback_QPdfSearchModel_insertRows(QPdfSearchModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_insertColumns(QPdfSearchModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_removeRows(QPdfSearchModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_removeColumns(QPdfSearchModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_moveRows(QPdfSearchModel*, intptr_t, QModelIndex*, int, int, QModelIndex*, int); +bool miqt_exec_callback_QPdfSearchModel_moveColumns(QPdfSearchModel*, intptr_t, QModelIndex*, int, int, QModelIndex*, int); +void miqt_exec_callback_QPdfSearchModel_fetchMore(QPdfSearchModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_canFetchMore(const QPdfSearchModel*, intptr_t, QModelIndex*); +void miqt_exec_callback_QPdfSearchModel_sort(QPdfSearchModel*, intptr_t, int, int); +QModelIndex* miqt_exec_callback_QPdfSearchModel_buddy(const QPdfSearchModel*, intptr_t, QModelIndex*); +struct miqt_array /* of QModelIndex* */ miqt_exec_callback_QPdfSearchModel_match(const QPdfSearchModel*, intptr_t, QModelIndex*, int, QVariant*, int, int); +QSize* miqt_exec_callback_QPdfSearchModel_span(const QPdfSearchModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_submit(QPdfSearchModel*, intptr_t); +void miqt_exec_callback_QPdfSearchModel_revert(QPdfSearchModel*, intptr_t); +bool miqt_exec_callback_QPdfSearchModel_event(QPdfSearchModel*, intptr_t, QEvent*); +bool miqt_exec_callback_QPdfSearchModel_eventFilter(QPdfSearchModel*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QPdfSearchModel_childEvent(QPdfSearchModel*, intptr_t, QChildEvent*); +void miqt_exec_callback_QPdfSearchModel_customEvent(QPdfSearchModel*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfSearchModel_connectNotify(QPdfSearchModel*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QPdfSearchModel_disconnectNotify(QPdfSearchModel*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQPdfSearchModel final : public QPdfSearchModel { +public: + + MiqtVirtualQPdfSearchModel(): QPdfSearchModel() {}; + MiqtVirtualQPdfSearchModel(QObject* parent): QPdfSearchModel(parent) {}; + + virtual ~MiqtVirtualQPdfSearchModel() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__roleNames = 0; + + // Subclass to allow providing a Go implementation + virtual QHash roleNames() const override { + if (handle__roleNames == 0) { + return QPdfSearchModel::roleNames(); + } + + + struct miqt_map /* of int to struct miqt_string */ callback_return_value = miqt_exec_callback_QPdfSearchModel_roleNames(this, handle__roleNames); + QHash callback_return_value_QMap; + callback_return_value_QMap.reserve(callback_return_value.len); + int* callback_return_value_karr = static_cast(callback_return_value.keys); + struct miqt_string* callback_return_value_varr = static_cast(callback_return_value.values); + for(size_t i = 0; i < callback_return_value.len; ++i) { + QByteArray callback_return_value_varr_i_QByteArray(callback_return_value_varr[i].data, callback_return_value_varr[i].len); + callback_return_value_QMap[static_cast(callback_return_value_karr[i])] = callback_return_value_varr_i_QByteArray; + } + + return callback_return_value_QMap; + } + + friend struct miqt_map /* of int to struct miqt_string */ QPdfSearchModel_virtualbase_roleNames(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__rowCount = 0; + + // Subclass to allow providing a Go implementation + virtual int rowCount(const QModelIndex& parent) const override { + if (handle__rowCount == 0) { + return QPdfSearchModel::rowCount(parent); + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + int callback_return_value = miqt_exec_callback_QPdfSearchModel_rowCount(this, handle__rowCount, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfSearchModel_virtualbase_rowCount(const void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__data = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant data(const QModelIndex& index, int role) const override { + if (handle__data == 0) { + return QPdfSearchModel::data(index, role); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + int sigval2 = role; + + QVariant* callback_return_value = miqt_exec_callback_QPdfSearchModel_data(this, handle__data, sigval1, sigval2); + + return *callback_return_value; + } + + friend QVariant* QPdfSearchModel_virtualbase_data(const void* self, QModelIndex* index, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__timerEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void timerEvent(QTimerEvent* event) override { + if (handle__timerEvent == 0) { + QPdfSearchModel::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + + miqt_exec_callback_QPdfSearchModel_timerEvent(this, handle__timerEvent, sigval1); + + + } + + friend void QPdfSearchModel_virtualbase_timerEvent(void* self, QTimerEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__index = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex index(int row, int column, const QModelIndex& parent) const override { + if (handle__index == 0) { + return QPdfSearchModel::index(row, column, parent); + } + + int sigval1 = row; + int sigval2 = column; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfSearchModel_index(this, handle__index, sigval1, sigval2, sigval3); + + return *callback_return_value; + } + + friend QModelIndex* QPdfSearchModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__sibling = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex sibling(int row, int column, const QModelIndex& idx) const override { + if (handle__sibling == 0) { + return QPdfSearchModel::sibling(row, column, idx); + } + + int sigval1 = row; + int sigval2 = column; + const QModelIndex& idx_ret = idx; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&idx_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfSearchModel_sibling(this, handle__sibling, sigval1, sigval2, sigval3); + + return *callback_return_value; + } + + friend QModelIndex* QPdfSearchModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx); + + // cgo.Handle value for overwritten implementation + intptr_t handle__dropMimeData = 0; + + // Subclass to allow providing a Go implementation + virtual bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override { + if (handle__dropMimeData == 0) { + return QPdfSearchModel::dropMimeData(data, action, row, column, parent); + } + + QMimeData* sigval1 = (QMimeData*) data; + Qt::DropAction action_ret = action; + int sigval2 = static_cast(action_ret); + int sigval3 = row; + int sigval4 = column; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval5 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_dropMimeData(this, handle__dropMimeData, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__flags = 0; + + // Subclass to allow providing a Go implementation + virtual Qt::ItemFlags flags(const QModelIndex& index) const override { + if (handle__flags == 0) { + return QPdfSearchModel::flags(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + int callback_return_value = miqt_exec_callback_QPdfSearchModel_flags(this, handle__flags, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfSearchModel_virtualbase_flags(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setData = 0; + + // Subclass to allow providing a Go implementation + virtual bool setData(const QModelIndex& index, const QVariant& value, int role) override { + if (handle__setData == 0) { + return QPdfSearchModel::setData(index, value, role); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval2 = const_cast(&value_ret); + int sigval3 = role; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_setData(this, handle__setData, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__headerData = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant headerData(int section, Qt::Orientation orientation, int role) const override { + if (handle__headerData == 0) { + return QPdfSearchModel::headerData(section, orientation, role); + } + + int sigval1 = section; + Qt::Orientation orientation_ret = orientation; + int sigval2 = static_cast(orientation_ret); + int sigval3 = role; + + QVariant* callback_return_value = miqt_exec_callback_QPdfSearchModel_headerData(this, handle__headerData, sigval1, sigval2, sigval3); + + return *callback_return_value; + } + + friend QVariant* QPdfSearchModel_virtualbase_headerData(const void* self, int section, int orientation, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setHeaderData = 0; + + // Subclass to allow providing a Go implementation + virtual bool setHeaderData(int section, Qt::Orientation orientation, const QVariant& value, int role) override { + if (handle__setHeaderData == 0) { + return QPdfSearchModel::setHeaderData(section, orientation, value, role); + } + + int sigval1 = section; + Qt::Orientation orientation_ret = orientation; + int sigval2 = static_cast(orientation_ret); + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval3 = const_cast(&value_ret); + int sigval4 = role; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_setHeaderData(this, handle__setHeaderData, sigval1, sigval2, sigval3, sigval4); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__itemData = 0; + + // Subclass to allow providing a Go implementation + virtual QMap itemData(const QModelIndex& index) const override { + if (handle__itemData == 0) { + return QPdfSearchModel::itemData(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + struct miqt_map /* of int to QVariant* */ callback_return_value = miqt_exec_callback_QPdfSearchModel_itemData(this, handle__itemData, sigval1); + QMap callback_return_value_QMap; + int* callback_return_value_karr = static_cast(callback_return_value.keys); + QVariant** callback_return_value_varr = static_cast(callback_return_value.values); + for(size_t i = 0; i < callback_return_value.len; ++i) { + callback_return_value_QMap[static_cast(callback_return_value_karr[i])] = *(callback_return_value_varr[i]); + } + + return callback_return_value_QMap; + } + + friend struct miqt_map /* of int to QVariant* */ QPdfSearchModel_virtualbase_itemData(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setItemData = 0; + + // Subclass to allow providing a Go implementation + virtual bool setItemData(const QModelIndex& index, const QMap& roles) override { + if (handle__setItemData == 0) { + return QPdfSearchModel::setItemData(index, roles); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + const QMap& roles_ret = roles; + // Convert QMap<> from C++ memory to manually-managed C memory + int* roles_karr = static_cast(malloc(sizeof(int) * roles_ret.size())); + QVariant** roles_varr = static_cast(malloc(sizeof(QVariant*) * roles_ret.size())); + int roles_ctr = 0; + for (auto roles_itr = roles_ret.keyValueBegin(); roles_itr != roles_ret.keyValueEnd(); ++roles_itr) { + roles_karr[roles_ctr] = roles_itr->first; + roles_varr[roles_ctr] = new QVariant(roles_itr->second); + roles_ctr++; + } + struct miqt_map roles_out; + roles_out.len = roles_ret.size(); + roles_out.keys = static_cast(roles_karr); + roles_out.values = static_cast(roles_varr); + struct miqt_map /* of int to QVariant* */ sigval2 = roles_out; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_setItemData(this, handle__setItemData, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */ roles); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mimeTypes = 0; + + // Subclass to allow providing a Go implementation + virtual QStringList mimeTypes() const override { + if (handle__mimeTypes == 0) { + return QPdfSearchModel::mimeTypes(); + } + + + struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QPdfSearchModel_mimeTypes(this, handle__mimeTypes); + QStringList callback_return_value_QList; + callback_return_value_QList.reserve(callback_return_value.len); + struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); + for(size_t i = 0; i < callback_return_value.len; ++i) { + QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); + callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + } + + return callback_return_value_QList; + } + + friend struct miqt_array /* of struct miqt_string */ QPdfSearchModel_virtualbase_mimeTypes(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mimeData = 0; + + // Subclass to allow providing a Go implementation + virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + if (handle__mimeData == 0) { + return QPdfSearchModel::mimeData(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; + + QMimeData* callback_return_value = miqt_exec_callback_QPdfSearchModel_mimeData(this, handle__mimeData, sigval1); + + return callback_return_value; + } + + friend QMimeData* QPdfSearchModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes); + + // cgo.Handle value for overwritten implementation + intptr_t handle__canDropMimeData = 0; + + // Subclass to allow providing a Go implementation + virtual bool canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const override { + if (handle__canDropMimeData == 0) { + return QPdfSearchModel::canDropMimeData(data, action, row, column, parent); + } + + QMimeData* sigval1 = (QMimeData*) data; + Qt::DropAction action_ret = action; + int sigval2 = static_cast(action_ret); + int sigval3 = row; + int sigval4 = column; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval5 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_canDropMimeData(this, handle__canDropMimeData, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__supportedDropActions = 0; + + // Subclass to allow providing a Go implementation + virtual Qt::DropActions supportedDropActions() const override { + if (handle__supportedDropActions == 0) { + return QPdfSearchModel::supportedDropActions(); + } + + + int callback_return_value = miqt_exec_callback_QPdfSearchModel_supportedDropActions(this, handle__supportedDropActions); + + return static_cast(callback_return_value); + } + + friend int QPdfSearchModel_virtualbase_supportedDropActions(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__supportedDragActions = 0; + + // Subclass to allow providing a Go implementation + virtual Qt::DropActions supportedDragActions() const override { + if (handle__supportedDragActions == 0) { + return QPdfSearchModel::supportedDragActions(); + } + + + int callback_return_value = miqt_exec_callback_QPdfSearchModel_supportedDragActions(this, handle__supportedDragActions); + + return static_cast(callback_return_value); + } + + friend int QPdfSearchModel_virtualbase_supportedDragActions(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__insertRows = 0; + + // Subclass to allow providing a Go implementation + virtual bool insertRows(int row, int count, const QModelIndex& parent) override { + if (handle__insertRows == 0) { + return QPdfSearchModel::insertRows(row, count, parent); + } + + int sigval1 = row; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_insertRows(this, handle__insertRows, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__insertColumns = 0; + + // Subclass to allow providing a Go implementation + virtual bool insertColumns(int column, int count, const QModelIndex& parent) override { + if (handle__insertColumns == 0) { + return QPdfSearchModel::insertColumns(column, count, parent); + } + + int sigval1 = column; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_insertColumns(this, handle__insertColumns, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__removeRows = 0; + + // Subclass to allow providing a Go implementation + virtual bool removeRows(int row, int count, const QModelIndex& parent) override { + if (handle__removeRows == 0) { + return QPdfSearchModel::removeRows(row, count, parent); + } + + int sigval1 = row; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_removeRows(this, handle__removeRows, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__removeColumns = 0; + + // Subclass to allow providing a Go implementation + virtual bool removeColumns(int column, int count, const QModelIndex& parent) override { + if (handle__removeColumns == 0) { + return QPdfSearchModel::removeColumns(column, count, parent); + } + + int sigval1 = column; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_removeColumns(this, handle__removeColumns, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__moveRows = 0; + + // Subclass to allow providing a Go implementation + virtual bool moveRows(const QModelIndex& sourceParent, int sourceRow, int count, const QModelIndex& destinationParent, int destinationChild) override { + if (handle__moveRows == 0) { + return QPdfSearchModel::moveRows(sourceParent, sourceRow, count, destinationParent, destinationChild); + } + + const QModelIndex& sourceParent_ret = sourceParent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&sourceParent_ret); + int sigval2 = sourceRow; + int sigval3 = count; + const QModelIndex& destinationParent_ret = destinationParent; + // Cast returned reference into pointer + QModelIndex* sigval4 = const_cast(&destinationParent_ret); + int sigval5 = destinationChild; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_moveRows(this, handle__moveRows, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild); + + // cgo.Handle value for overwritten implementation + intptr_t handle__moveColumns = 0; + + // Subclass to allow providing a Go implementation + virtual bool moveColumns(const QModelIndex& sourceParent, int sourceColumn, int count, const QModelIndex& destinationParent, int destinationChild) override { + if (handle__moveColumns == 0) { + return QPdfSearchModel::moveColumns(sourceParent, sourceColumn, count, destinationParent, destinationChild); + } + + const QModelIndex& sourceParent_ret = sourceParent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&sourceParent_ret); + int sigval2 = sourceColumn; + int sigval3 = count; + const QModelIndex& destinationParent_ret = destinationParent; + // Cast returned reference into pointer + QModelIndex* sigval4 = const_cast(&destinationParent_ret); + int sigval5 = destinationChild; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_moveColumns(this, handle__moveColumns, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild); + + // cgo.Handle value for overwritten implementation + intptr_t handle__fetchMore = 0; + + // Subclass to allow providing a Go implementation + virtual void fetchMore(const QModelIndex& parent) override { + if (handle__fetchMore == 0) { + QPdfSearchModel::fetchMore(parent); + return; + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + miqt_exec_callback_QPdfSearchModel_fetchMore(this, handle__fetchMore, sigval1); + + + } + + friend void QPdfSearchModel_virtualbase_fetchMore(void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__canFetchMore = 0; + + // Subclass to allow providing a Go implementation + virtual bool canFetchMore(const QModelIndex& parent) const override { + if (handle__canFetchMore == 0) { + return QPdfSearchModel::canFetchMore(parent); + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_canFetchMore(this, handle__canFetchMore, sigval1); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__sort = 0; + + // Subclass to allow providing a Go implementation + virtual void sort(int column, Qt::SortOrder order) override { + if (handle__sort == 0) { + QPdfSearchModel::sort(column, order); + return; + } + + int sigval1 = column; + Qt::SortOrder order_ret = order; + int sigval2 = static_cast(order_ret); + + miqt_exec_callback_QPdfSearchModel_sort(this, handle__sort, sigval1, sigval2); + + + } + + friend void QPdfSearchModel_virtualbase_sort(void* self, int column, int order); + + // cgo.Handle value for overwritten implementation + intptr_t handle__buddy = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex buddy(const QModelIndex& index) const override { + if (handle__buddy == 0) { + return QPdfSearchModel::buddy(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfSearchModel_buddy(this, handle__buddy, sigval1); + + return *callback_return_value; + } + + friend QModelIndex* QPdfSearchModel_virtualbase_buddy(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__match = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + if (handle__match == 0) { + return QPdfSearchModel::match(start, role, value, hits, flags); + } + + const QModelIndex& start_ret = start; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&start_ret); + int sigval2 = role; + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval3 = const_cast(&value_ret); + int sigval4 = hits; + Qt::MatchFlags flags_ret = flags; + int sigval5 = static_cast(flags_ret); + + struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QPdfSearchModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); + 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; + } + + friend struct miqt_array /* of QModelIndex* */ QPdfSearchModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); + + // cgo.Handle value for overwritten implementation + intptr_t handle__span = 0; + + // Subclass to allow providing a Go implementation + virtual QSize span(const QModelIndex& index) const override { + if (handle__span == 0) { + return QPdfSearchModel::span(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + QSize* callback_return_value = miqt_exec_callback_QPdfSearchModel_span(this, handle__span, sigval1); + + return *callback_return_value; + } + + friend QSize* QPdfSearchModel_virtualbase_span(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__submit = 0; + + // Subclass to allow providing a Go implementation + virtual bool submit() override { + if (handle__submit == 0) { + return QPdfSearchModel::submit(); + } + + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_submit(this, handle__submit); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_submit(void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__revert = 0; + + // Subclass to allow providing a Go implementation + virtual void revert() override { + if (handle__revert == 0) { + QPdfSearchModel::revert(); + return; + } + + + miqt_exec_callback_QPdfSearchModel_revert(this, handle__revert); + + + } + + friend void QPdfSearchModel_virtualbase_revert(void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QPdfSearchModel::event(event); + } + + QEvent* sigval1 = event; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_event(this, handle__event, sigval1); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QPdfSearchModel::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_eventFilter(this, handle__eventFilter, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__childEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void childEvent(QChildEvent* event) override { + if (handle__childEvent == 0) { + QPdfSearchModel::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + + miqt_exec_callback_QPdfSearchModel_childEvent(this, handle__childEvent, sigval1); + + + } + + friend void QPdfSearchModel_virtualbase_childEvent(void* self, QChildEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__customEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void customEvent(QEvent* event) override { + if (handle__customEvent == 0) { + QPdfSearchModel::customEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfSearchModel_customEvent(this, handle__customEvent, sigval1); + + + } + + friend void QPdfSearchModel_virtualbase_customEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__connectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void connectNotify(const QMetaMethod& signal) override { + if (handle__connectNotify == 0) { + QPdfSearchModel::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfSearchModel_connectNotify(this, handle__connectNotify, sigval1); + + + } + + friend void QPdfSearchModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); + + // cgo.Handle value for overwritten implementation + intptr_t handle__disconnectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void disconnectNotify(const QMetaMethod& signal) override { + if (handle__disconnectNotify == 0) { + QPdfSearchModel::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfSearchModel_disconnectNotify(this, handle__disconnectNotify, sigval1); + + + } + + friend void QPdfSearchModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend void QPdfSearchModel_protectedbase_updatePage(bool* _dynamic_cast_ok, void* self, int page); + friend void QPdfSearchModel_protectedbase_resetInternalData(bool* _dynamic_cast_ok, void* self); + friend QModelIndex* QPdfSearchModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column); + friend void QPdfSearchModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */ indexes, QDataStream* stream); + friend bool QPdfSearchModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream); + friend void QPdfSearchModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfSearchModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self); + friend void QPdfSearchModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfSearchModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self); + friend bool QPdfSearchModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow); + friend void QPdfSearchModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self); + friend void QPdfSearchModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfSearchModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self); + friend void QPdfSearchModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfSearchModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self); + friend bool QPdfSearchModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn); + friend void QPdfSearchModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self); + friend void QPdfSearchModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self); + friend void QPdfSearchModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self); + friend void QPdfSearchModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to); + friend void QPdfSearchModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */ from, struct miqt_array /* of QModelIndex* */ to); + friend struct miqt_array /* of QModelIndex* */ QPdfSearchModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self); + friend QObject* QPdfSearchModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QPdfSearchModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QPdfSearchModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QPdfSearchModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QPdfSearchModel* QPdfSearchModel_new() { + return new MiqtVirtualQPdfSearchModel(); +} + +QPdfSearchModel* QPdfSearchModel_new2(QObject* parent) { + return new MiqtVirtualQPdfSearchModel(parent); +} + +void QPdfSearchModel_virtbase(QPdfSearchModel* src, QAbstractListModel** outptr_QAbstractListModel) { + *outptr_QAbstractListModel = static_cast(src); +} + +QMetaObject* QPdfSearchModel_metaObject(const QPdfSearchModel* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QPdfSearchModel_metacast(QPdfSearchModel* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QPdfSearchModel_tr(const char* s) { + QString _ret = QPdfSearchModel::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 QPdfSearchModel_trUtf8(const char* s) { + QString _ret = QPdfSearchModel::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; +} + +struct miqt_array /* of QPdfSearchResult* */ QPdfSearchModel_resultsOnPage(const QPdfSearchModel* self, int page) { + QVector _ret = self->resultsOnPage(static_cast(page)); + // Convert QList<> from C++ memory to manually-managed C memory + QPdfSearchResult** _arr = static_cast(malloc(sizeof(QPdfSearchResult*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QPdfSearchResult(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +QPdfSearchResult* QPdfSearchModel_resultAtIndex(const QPdfSearchModel* self, int index) { + return new QPdfSearchResult(self->resultAtIndex(static_cast(index))); +} + +QPdfDocument* QPdfSearchModel_document(const QPdfSearchModel* self) { + return self->document(); +} + +struct miqt_string QPdfSearchModel_searchString(const QPdfSearchModel* self) { + QString _ret = self->searchString(); + // 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_map /* of int to struct miqt_string */ QPdfSearchModel_roleNames(const QPdfSearchModel* self) { + QHash _ret = self->roleNames(); + // Convert QMap<> from C++ memory to manually-managed C memory + int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); + struct miqt_string* _varr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + _karr[_ctr] = _itr->first; + QByteArray _hashval_qb = _itr->second; + struct miqt_string _hashval_ms; + _hashval_ms.len = _hashval_qb.length(); + _hashval_ms.data = static_cast(malloc(_hashval_ms.len)); + memcpy(_hashval_ms.data, _hashval_qb.data(), _hashval_ms.len); + _varr[_ctr] = _hashval_ms; + _ctr++; + } + struct miqt_map _out; + _out.len = _ret.size(); + _out.keys = static_cast(_karr); + _out.values = static_cast(_varr); + return _out; +} + +int QPdfSearchModel_rowCount(const QPdfSearchModel* self, QModelIndex* parent) { + return self->rowCount(*parent); +} + +QVariant* QPdfSearchModel_data(const QPdfSearchModel* self, QModelIndex* index, int role) { + return new QVariant(self->data(*index, static_cast(role))); +} + +void QPdfSearchModel_setSearchString(QPdfSearchModel* self, struct miqt_string searchString) { + QString searchString_QString = QString::fromUtf8(searchString.data, searchString.len); + self->setSearchString(searchString_QString); +} + +void QPdfSearchModel_setDocument(QPdfSearchModel* self, QPdfDocument* document) { + self->setDocument(document); +} + +void QPdfSearchModel_documentChanged(QPdfSearchModel* self) { + self->documentChanged(); +} + +void QPdfSearchModel_connect_documentChanged(QPdfSearchModel* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel::connect(self, static_cast(&QPdfSearchModel::documentChanged), self, [=]() { + miqt_exec_callback_QPdfSearchModel_documentChanged(slot); + }); +} + +void QPdfSearchModel_searchStringChanged(QPdfSearchModel* self) { + self->searchStringChanged(); +} + +void QPdfSearchModel_connect_searchStringChanged(QPdfSearchModel* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel::connect(self, static_cast(&QPdfSearchModel::searchStringChanged), self, [=]() { + miqt_exec_callback_QPdfSearchModel_searchStringChanged(slot); + }); +} + +struct miqt_string QPdfSearchModel_tr2(const char* s, const char* c) { + QString _ret = QPdfSearchModel::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 QPdfSearchModel_tr3(const char* s, const char* c, int n) { + QString _ret = QPdfSearchModel::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 QPdfSearchModel_trUtf82(const char* s, const char* c) { + QString _ret = QPdfSearchModel::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 QPdfSearchModel_trUtf83(const char* s, const char* c, int n) { + QString _ret = QPdfSearchModel::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; +} + +bool QPdfSearchModel_override_virtual_roleNames(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__roleNames = slot; + return true; +} + +struct miqt_map /* of int to struct miqt_string */ QPdfSearchModel_virtualbase_roleNames(const void* self) { + + QHash _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::roleNames(); + // Convert QMap<> from C++ memory to manually-managed C memory + int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); + struct miqt_string* _varr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + _karr[_ctr] = _itr->first; + QByteArray _hashval_qb = _itr->second; + struct miqt_string _hashval_ms; + _hashval_ms.len = _hashval_qb.length(); + _hashval_ms.data = static_cast(malloc(_hashval_ms.len)); + memcpy(_hashval_ms.data, _hashval_qb.data(), _hashval_ms.len); + _varr[_ctr] = _hashval_ms; + _ctr++; + } + struct miqt_map _out; + _out.len = _ret.size(); + _out.keys = static_cast(_karr); + _out.values = static_cast(_varr); + return _out; + +} + +bool QPdfSearchModel_override_virtual_rowCount(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__rowCount = slot; + return true; +} + +int QPdfSearchModel_virtualbase_rowCount(const void* self, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::rowCount(*parent); + +} + +bool QPdfSearchModel_override_virtual_data(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__data = slot; + return true; +} + +QVariant* QPdfSearchModel_virtualbase_data(const void* self, QModelIndex* index, int role) { + + return new QVariant(( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::data(*index, static_cast(role))); + +} + +bool QPdfSearchModel_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QPdfSearchModel_virtualbase_timerEvent(void* self, QTimerEvent* event) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::timerEvent(event); + +} + +bool QPdfSearchModel_override_virtual_index(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__index = slot; + return true; +} + +QModelIndex* QPdfSearchModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent) { + + return new QModelIndex(( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::index(static_cast(row), static_cast(column), *parent)); + +} + +bool QPdfSearchModel_override_virtual_sibling(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__sibling = slot; + return true; +} + +QModelIndex* QPdfSearchModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx) { + + return new QModelIndex(( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::sibling(static_cast(row), static_cast(column), *idx)); + +} + +bool QPdfSearchModel_override_virtual_dropMimeData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__dropMimeData = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::dropMimeData(data, static_cast(action), static_cast(row), static_cast(column), *parent); + +} + +bool QPdfSearchModel_override_virtual_flags(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__flags = slot; + return true; +} + +int QPdfSearchModel_virtualbase_flags(const void* self, QModelIndex* index) { + + Qt::ItemFlags _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::flags(*index); + return static_cast(_ret); + +} + +bool QPdfSearchModel_override_virtual_setData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setData = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::setData(*index, *value, static_cast(role)); + +} + +bool QPdfSearchModel_override_virtual_headerData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__headerData = slot; + return true; +} + +QVariant* QPdfSearchModel_virtualbase_headerData(const void* self, int section, int orientation, int role) { + + return new QVariant(( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::headerData(static_cast(section), static_cast(orientation), static_cast(role))); + +} + +bool QPdfSearchModel_override_virtual_setHeaderData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setHeaderData = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::setHeaderData(static_cast(section), static_cast(orientation), *value, static_cast(role)); + +} + +bool QPdfSearchModel_override_virtual_itemData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__itemData = slot; + return true; +} + +struct miqt_map /* of int to QVariant* */ QPdfSearchModel_virtualbase_itemData(const void* self, QModelIndex* index) { + + QMap _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::itemData(*index); + // Convert QMap<> from C++ memory to manually-managed C memory + int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); + QVariant** _varr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + _karr[_ctr] = _itr->first; + _varr[_ctr] = new QVariant(_itr->second); + _ctr++; + } + struct miqt_map _out; + _out.len = _ret.size(); + _out.keys = static_cast(_karr); + _out.values = static_cast(_varr); + return _out; + +} + +bool QPdfSearchModel_override_virtual_setItemData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setItemData = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */ roles) { + QMap roles_QMap; + int* roles_karr = static_cast(roles.keys); + QVariant** roles_varr = static_cast(roles.values); + for(size_t i = 0; i < roles.len; ++i) { + roles_QMap[static_cast(roles_karr[i])] = *(roles_varr[i]); + } + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::setItemData(*index, roles_QMap); + +} + +bool QPdfSearchModel_override_virtual_mimeTypes(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mimeTypes = slot; + return true; +} + +struct miqt_array /* of struct miqt_string */ QPdfSearchModel_virtualbase_mimeTypes(const void* self) { + + QStringList _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::mimeTypes(); + // Convert QList<> from C++ memory to manually-managed C memory + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QString _lv_ret = _ret[i]; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _lv_b = _lv_ret.toUtf8(); + struct miqt_string _lv_ms; + _lv_ms.len = _lv_b.length(); + _lv_ms.data = static_cast(malloc(_lv_ms.len)); + memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len); + _arr[i] = _lv_ms; + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; + +} + +bool QPdfSearchModel_override_virtual_mimeData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mimeData = slot; + return true; +} + +QMimeData* QPdfSearchModel_virtualbase_mimeData(const void* 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])); + } + + return ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::mimeData(indexes_QList); + +} + +bool QPdfSearchModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__canDropMimeData = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::canDropMimeData(data, static_cast(action), static_cast(row), static_cast(column), *parent); + +} + +bool QPdfSearchModel_override_virtual_supportedDropActions(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__supportedDropActions = slot; + return true; +} + +int QPdfSearchModel_virtualbase_supportedDropActions(const void* self) { + + Qt::DropActions _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::supportedDropActions(); + return static_cast(_ret); + +} + +bool QPdfSearchModel_override_virtual_supportedDragActions(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__supportedDragActions = slot; + return true; +} + +int QPdfSearchModel_virtualbase_supportedDragActions(const void* self) { + + Qt::DropActions _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::supportedDragActions(); + return static_cast(_ret); + +} + +bool QPdfSearchModel_override_virtual_insertRows(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__insertRows = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::insertRows(static_cast(row), static_cast(count), *parent); + +} + +bool QPdfSearchModel_override_virtual_insertColumns(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__insertColumns = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::insertColumns(static_cast(column), static_cast(count), *parent); + +} + +bool QPdfSearchModel_override_virtual_removeRows(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__removeRows = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::removeRows(static_cast(row), static_cast(count), *parent); + +} + +bool QPdfSearchModel_override_virtual_removeColumns(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__removeColumns = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::removeColumns(static_cast(column), static_cast(count), *parent); + +} + +bool QPdfSearchModel_override_virtual_moveRows(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__moveRows = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::moveRows(*sourceParent, static_cast(sourceRow), static_cast(count), *destinationParent, static_cast(destinationChild)); + +} + +bool QPdfSearchModel_override_virtual_moveColumns(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__moveColumns = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::moveColumns(*sourceParent, static_cast(sourceColumn), static_cast(count), *destinationParent, static_cast(destinationChild)); + +} + +bool QPdfSearchModel_override_virtual_fetchMore(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__fetchMore = slot; + return true; +} + +void QPdfSearchModel_virtualbase_fetchMore(void* self, QModelIndex* parent) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::fetchMore(*parent); + +} + +bool QPdfSearchModel_override_virtual_canFetchMore(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__canFetchMore = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::canFetchMore(*parent); + +} + +bool QPdfSearchModel_override_virtual_sort(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__sort = slot; + return true; +} + +void QPdfSearchModel_virtualbase_sort(void* self, int column, int order) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::sort(static_cast(column), static_cast(order)); + +} + +bool QPdfSearchModel_override_virtual_buddy(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__buddy = slot; + return true; +} + +QModelIndex* QPdfSearchModel_virtualbase_buddy(const void* self, QModelIndex* index) { + + return new QModelIndex(( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::buddy(*index)); + +} + +bool QPdfSearchModel_override_virtual_match(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__match = slot; + return true; +} + +struct miqt_array /* of QModelIndex* */ QPdfSearchModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { + + QModelIndexList _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + // 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; + +} + +bool QPdfSearchModel_override_virtual_span(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__span = slot; + return true; +} + +QSize* QPdfSearchModel_virtualbase_span(const void* self, QModelIndex* index) { + + return new QSize(( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::span(*index)); + +} + +bool QPdfSearchModel_override_virtual_submit(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__submit = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_submit(void* self) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::submit(); + +} + +bool QPdfSearchModel_override_virtual_revert(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__revert = slot; + return true; +} + +void QPdfSearchModel_virtualbase_revert(void* self) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::revert(); + +} + +bool QPdfSearchModel_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_event(void* self, QEvent* event) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::event(event); + +} + +bool QPdfSearchModel_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::eventFilter(watched, event); + +} + +bool QPdfSearchModel_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QPdfSearchModel_virtualbase_childEvent(void* self, QChildEvent* event) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::childEvent(event); + +} + +bool QPdfSearchModel_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QPdfSearchModel_virtualbase_customEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::customEvent(event); + +} + +bool QPdfSearchModel_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QPdfSearchModel_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::connectNotify(*signal); + +} + +bool QPdfSearchModel_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QPdfSearchModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::disconnectNotify(*signal); + +} + +void QPdfSearchModel_protectedbase_updatePage(bool* _dynamic_cast_ok, void* self, int page) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->updatePage(static_cast(page)); + +} + +void QPdfSearchModel_protectedbase_resetInternalData(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->resetInternalData(); + +} + +QModelIndex* QPdfSearchModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return new QModelIndex(self_cast->createIndex(static_cast(row), static_cast(column))); + +} + +void QPdfSearchModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */ indexes, QDataStream* stream) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + 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_cast->encodeData(indexes_QList, *stream); + +} + +bool QPdfSearchModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->decodeData(static_cast(row), static_cast(column), *parent, *stream); + +} + +void QPdfSearchModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginInsertRows(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfSearchModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endInsertRows(); + +} + +void QPdfSearchModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginRemoveRows(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfSearchModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endRemoveRows(); + +} + +bool QPdfSearchModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->beginMoveRows(*sourceParent, static_cast(sourceFirst), static_cast(sourceLast), *destinationParent, static_cast(destinationRow)); + +} + +void QPdfSearchModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endMoveRows(); + +} + +void QPdfSearchModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginInsertColumns(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfSearchModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endInsertColumns(); + +} + +void QPdfSearchModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginRemoveColumns(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfSearchModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endRemoveColumns(); + +} + +bool QPdfSearchModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->beginMoveColumns(*sourceParent, static_cast(sourceFirst), static_cast(sourceLast), *destinationParent, static_cast(destinationColumn)); + +} + +void QPdfSearchModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endMoveColumns(); + +} + +void QPdfSearchModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginResetModel(); + +} + +void QPdfSearchModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endResetModel(); + +} + +void QPdfSearchModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->changePersistentIndex(*from, *to); + +} + +void QPdfSearchModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */ from, struct miqt_array /* of QModelIndex* */ to) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + QModelIndexList from_QList; + from_QList.reserve(from.len); + QModelIndex** from_arr = static_cast(from.data); + for(size_t i = 0; i < from.len; ++i) { + from_QList.push_back(*(from_arr[i])); + } + QModelIndexList to_QList; + to_QList.reserve(to.len); + QModelIndex** to_arr = static_cast(to.data); + for(size_t i = 0; i < to.len; ++i) { + to_QList.push_back(*(to_arr[i])); + } + + self_cast->changePersistentIndexList(from_QList, to_QList); + +} + +struct miqt_array /* of QModelIndex* */ QPdfSearchModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return (struct miqt_array){}; + } + + *_dynamic_cast_ok = true; + + QModelIndexList _ret = self_cast->persistentIndexList(); + // 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; + +} + +QObject* QPdfSearchModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return self_cast->sender(); + +} + +int QPdfSearchModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->senderSignalIndex(); + +} + +int QPdfSearchModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->receivers(signal); + +} + +bool QPdfSearchModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->isSignalConnected(*signal); + +} + +void QPdfSearchModel_delete(QPdfSearchModel* self) { + delete self; +} + diff --git a/qt/pdf/gen_qpdfsearchmodel.go b/qt/pdf/gen_qpdfsearchmodel.go new file mode 100644 index 00000000..27194a25 --- /dev/null +++ b/qt/pdf/gen_qpdfsearchmodel.go @@ -0,0 +1,1889 @@ +package pdf + +/* + +#include "gen_qpdfsearchmodel.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QPdfSearchModel__Role int + +const ( + QPdfSearchModel__Page QPdfSearchModel__Role = 256 + QPdfSearchModel__IndexOnPage QPdfSearchModel__Role = 257 + QPdfSearchModel__Location QPdfSearchModel__Role = 258 + QPdfSearchModel__ContextBefore QPdfSearchModel__Role = 259 + QPdfSearchModel__ContextAfter QPdfSearchModel__Role = 260 + QPdfSearchModel___Count QPdfSearchModel__Role = 261 +) + +type QPdfSearchModel struct { + h *C.QPdfSearchModel + *qt.QAbstractListModel +} + +func (this *QPdfSearchModel) cPointer() *C.QPdfSearchModel { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfSearchModel) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfSearchModel constructs the type using only CGO pointers. +func newQPdfSearchModel(h *C.QPdfSearchModel) *QPdfSearchModel { + if h == nil { + return nil + } + var outptr_QAbstractListModel *C.QAbstractListModel = nil + C.QPdfSearchModel_virtbase(h, &outptr_QAbstractListModel) + + return &QPdfSearchModel{h: h, + QAbstractListModel: qt.UnsafeNewQAbstractListModel(unsafe.Pointer(outptr_QAbstractListModel))} +} + +// UnsafeNewQPdfSearchModel constructs the type using only unsafe pointers. +func UnsafeNewQPdfSearchModel(h unsafe.Pointer) *QPdfSearchModel { + return newQPdfSearchModel((*C.QPdfSearchModel)(h)) +} + +// NewQPdfSearchModel constructs a new QPdfSearchModel object. +func NewQPdfSearchModel() *QPdfSearchModel { + + return newQPdfSearchModel(C.QPdfSearchModel_new()) +} + +// NewQPdfSearchModel2 constructs a new QPdfSearchModel object. +func NewQPdfSearchModel2(parent *qt.QObject) *QPdfSearchModel { + + return newQPdfSearchModel(C.QPdfSearchModel_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QPdfSearchModel) MetaObject() *qt.QMetaObject { + return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QPdfSearchModel_metaObject(this.h))) +} + +func (this *QPdfSearchModel) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QPdfSearchModel_metacast(this.h, param1_Cstring)) +} + +func QPdfSearchModel_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfSearchModel_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfSearchModel_TrUtf8(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfSearchModel_trUtf8(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfSearchModel) ResultsOnPage(page int) []QPdfSearchResult { + var _ma C.struct_miqt_array = C.QPdfSearchModel_resultsOnPage(this.h, (C.int)(page)) + _ret := make([]QPdfSearchResult, int(_ma.len)) + _outCast := (*[0xffff]*C.QPdfSearchResult)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _vv_goptr := newQPdfSearchResult(_outCast[i]) + _vv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_vv_goptr + } + return _ret +} + +func (this *QPdfSearchModel) ResultAtIndex(index int) *QPdfSearchResult { + _goptr := newQPdfSearchResult(C.QPdfSearchModel_resultAtIndex(this.h, (C.int)(index))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfSearchModel) Document() *QPdfDocument { + return newQPdfDocument(C.QPdfSearchModel_document(this.h)) +} + +func (this *QPdfSearchModel) SearchString() string { + var _ms C.struct_miqt_string = C.QPdfSearchModel_searchString(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfSearchModel) RoleNames() map[int][]byte { + var _mm C.struct_miqt_map = C.QPdfSearchModel_roleNames(this.h) + _ret := make(map[int][]byte, int(_mm.len)) + _Keys := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + _entry_Key := (int)(_Keys[i]) + + var _hashval_bytearray C.struct_miqt_string = _Values[i] + _hashval_ret := C.GoBytes(unsafe.Pointer(_hashval_bytearray.data), C.int(int64(_hashval_bytearray.len))) + C.free(unsafe.Pointer(_hashval_bytearray.data)) + _entry_Value := _hashval_ret + _ret[_entry_Key] = _entry_Value + } + return _ret +} + +func (this *QPdfSearchModel) RowCount(parent *qt.QModelIndex) int { + return (int)(C.QPdfSearchModel_rowCount(this.h, (*C.QModelIndex)(parent.UnsafePointer()))) +} + +func (this *QPdfSearchModel) Data(index *qt.QModelIndex, role int) *qt.QVariant { + _goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QPdfSearchModel_data(this.h, (*C.QModelIndex)(index.UnsafePointer()), (C.int)(role)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfSearchModel) SetSearchString(searchString string) { + searchString_ms := C.struct_miqt_string{} + searchString_ms.data = C.CString(searchString) + searchString_ms.len = C.size_t(len(searchString)) + defer C.free(unsafe.Pointer(searchString_ms.data)) + C.QPdfSearchModel_setSearchString(this.h, searchString_ms) +} + +func (this *QPdfSearchModel) SetDocument(document *QPdfDocument) { + C.QPdfSearchModel_setDocument(this.h, document.cPointer()) +} + +func (this *QPdfSearchModel) DocumentChanged() { + C.QPdfSearchModel_documentChanged(this.h) +} +func (this *QPdfSearchModel) OnDocumentChanged(slot func()) { + C.QPdfSearchModel_connect_documentChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfSearchModel_documentChanged +func miqt_exec_callback_QPdfSearchModel_documentChanged(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *QPdfSearchModel) SearchStringChanged() { + C.QPdfSearchModel_searchStringChanged(this.h) +} +func (this *QPdfSearchModel) OnSearchStringChanged(slot func()) { + C.QPdfSearchModel_connect_searchStringChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfSearchModel_searchStringChanged +func miqt_exec_callback_QPdfSearchModel_searchStringChanged(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func QPdfSearchModel_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfSearchModel_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfSearchModel_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfSearchModel_tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfSearchModel_TrUtf82(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfSearchModel_trUtf82(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfSearchModel_TrUtf83(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfSearchModel_trUtf83(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +// UpdatePage can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) UpdatePage(page int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_updatePage(&_dynamic_cast_ok, unsafe.Pointer(this.h), (C.int)(page)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// ResetInternalData can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) ResetInternalData() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_resetInternalData(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// CreateIndex can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) CreateIndex(row int, column int) qt.QModelIndex { + + var _dynamic_cast_ok C.bool = false + _goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfSearchModel_protectedbase_createIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h), (C.int)(row), (C.int)(column)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _method_ret := *_goptr + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// EncodeData can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EncodeData(indexes []qt.QModelIndex, stream *qt.QDataStream) { + indexes_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(indexes)))) + defer C.free(unsafe.Pointer(indexes_CArray)) + for i := range indexes { + indexes_CArray[i] = (*C.QModelIndex)(indexes[i].UnsafePointer()) + } + indexes_ma := C.struct_miqt_array{len: C.size_t(len(indexes)), data: unsafe.Pointer(indexes_CArray)} + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_encodeData(&_dynamic_cast_ok, unsafe.Pointer(this.h), indexes_ma, (*C.QDataStream)(stream.UnsafePointer())) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// DecodeData can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) DecodeData(row int, column int, parent *qt.QModelIndex, stream *qt.QDataStream) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfSearchModel_protectedbase_decodeData(&_dynamic_cast_ok, unsafe.Pointer(this.h), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer()), (*C.QDataStream)(stream.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// BeginInsertRows can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginInsertRows(parent *qt.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_beginInsertRows(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndInsertRows can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndInsertRows() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endInsertRows(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginRemoveRows can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginRemoveRows(parent *qt.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_beginRemoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndRemoveRows can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndRemoveRows() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endRemoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginMoveRows can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginMoveRows(sourceParent *qt.QModelIndex, sourceFirst int, sourceLast int, destinationParent *qt.QModelIndex, destinationRow int) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfSearchModel_protectedbase_beginMoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceFirst), (C.int)(sourceLast), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationRow))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// EndMoveRows can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndMoveRows() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endMoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginInsertColumns can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginInsertColumns(parent *qt.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_beginInsertColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndInsertColumns can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndInsertColumns() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endInsertColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginRemoveColumns can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginRemoveColumns(parent *qt.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_beginRemoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndRemoveColumns can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndRemoveColumns() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endRemoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginMoveColumns can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginMoveColumns(sourceParent *qt.QModelIndex, sourceFirst int, sourceLast int, destinationParent *qt.QModelIndex, destinationColumn int) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfSearchModel_protectedbase_beginMoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceFirst), (C.int)(sourceLast), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationColumn))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// EndMoveColumns can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndMoveColumns() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endMoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginResetModel can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginResetModel() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_beginResetModel(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndResetModel can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndResetModel() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endResetModel(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// ChangePersistentIndex can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) ChangePersistentIndex(from *qt.QModelIndex, to *qt.QModelIndex) { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_changePersistentIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(from.UnsafePointer()), (*C.QModelIndex)(to.UnsafePointer())) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// ChangePersistentIndexList can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) ChangePersistentIndexList(from []qt.QModelIndex, to []qt.QModelIndex) { + from_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(from)))) + defer C.free(unsafe.Pointer(from_CArray)) + for i := range from { + from_CArray[i] = (*C.QModelIndex)(from[i].UnsafePointer()) + } + from_ma := C.struct_miqt_array{len: C.size_t(len(from)), data: unsafe.Pointer(from_CArray)} + to_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(to)))) + defer C.free(unsafe.Pointer(to_CArray)) + for i := range to { + to_CArray[i] = (*C.QModelIndex)(to[i].UnsafePointer()) + } + to_ma := C.struct_miqt_array{len: C.size_t(len(to)), data: unsafe.Pointer(to_CArray)} + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_changePersistentIndexList(&_dynamic_cast_ok, unsafe.Pointer(this.h), from_ma, to_ma) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// PersistentIndexList can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) PersistentIndexList() []qt.QModelIndex { + + var _dynamic_cast_ok C.bool = false + var _ma C.struct_miqt_array = C.QPdfSearchModel_protectedbase_persistentIndexList(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + _ret := make([]qt.QModelIndex, int(_ma.len)) + _outCast := (*[0xffff]*C.QModelIndex)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(_outCast[i])) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + _method_ret := _ret + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Sender can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) Sender() *qt.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt.UnsafeNewQObject(unsafe.Pointer(C.QPdfSearchModel_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// SenderSignalIndex can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfSearchModel_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Receivers can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) Receivers(signal string) int { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfSearchModel_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// IsSignalConnected can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) IsSignalConnected(signal *qt.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfSearchModel_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +func (this *QPdfSearchModel) callVirtualBase_RoleNames() map[int][]byte { + + var _mm C.struct_miqt_map = C.QPdfSearchModel_virtualbase_roleNames(unsafe.Pointer(this.h)) + _ret := make(map[int][]byte, int(_mm.len)) + _Keys := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + _entry_Key := (int)(_Keys[i]) + + var _hashval_bytearray C.struct_miqt_string = _Values[i] + _hashval_ret := C.GoBytes(unsafe.Pointer(_hashval_bytearray.data), C.int(int64(_hashval_bytearray.len))) + C.free(unsafe.Pointer(_hashval_bytearray.data)) + _entry_Value := _hashval_ret + _ret[_entry_Key] = _entry_Value + } + return _ret + +} +func (this *QPdfSearchModel) OnRoleNames(slot func(super func() map[int][]byte) map[int][]byte) { + ok := C.QPdfSearchModel_override_virtual_roleNames(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_roleNames +func miqt_exec_callback_QPdfSearchModel_roleNames(self *C.QPdfSearchModel, cb C.intptr_t) C.struct_miqt_map { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() map[int][]byte) map[int][]byte) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_RoleNames) + virtualReturn_Keys_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Keys_CArray)) + virtualReturn_Values_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Values_CArray)) + virtualReturn_ctr := 0 + for virtualReturn_k, virtualReturn_v := range virtualReturn { + virtualReturn_Keys_CArray[virtualReturn_ctr] = (C.int)(virtualReturn_k) + virtualReturn_v_alias := C.struct_miqt_string{} + if len(virtualReturn_v) > 0 { + virtualReturn_v_alias.data = (*C.char)(unsafe.Pointer(&virtualReturn_v[0])) + } else { + virtualReturn_v_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + virtualReturn_v_alias.len = C.size_t(len(virtualReturn_v)) + virtualReturn_Values_CArray[virtualReturn_ctr] = virtualReturn_v_alias + virtualReturn_ctr++ + } + virtualReturn_mm := C.struct_miqt_map{ + len: C.size_t(len(virtualReturn)), + keys: unsafe.Pointer(virtualReturn_Keys_CArray), + values: unsafe.Pointer(virtualReturn_Values_CArray), + } + + return virtualReturn_mm + +} + +func (this *QPdfSearchModel) callVirtualBase_RowCount(parent *qt.QModelIndex) int { + + return (int)(C.QPdfSearchModel_virtualbase_rowCount(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnRowCount(slot func(super func(parent *qt.QModelIndex) int, parent *qt.QModelIndex) int) { + ok := C.QPdfSearchModel_override_virtual_rowCount(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_rowCount +func miqt_exec_callback_QPdfSearchModel_rowCount(self *C.QPdfSearchModel, cb C.intptr_t, parent *C.QModelIndex) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt.QModelIndex) int, parent *qt.QModelIndex) int) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_RowCount, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_Data(index *qt.QModelIndex, role int) *qt.QVariant { + + _goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QPdfSearchModel_virtualbase_data(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), (C.int)(role)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfSearchModel) OnData(slot func(super func(index *qt.QModelIndex, role int) *qt.QVariant, index *qt.QModelIndex, role int) *qt.QVariant) { + ok := C.QPdfSearchModel_override_virtual_data(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_data +func miqt_exec_callback_QPdfSearchModel_data(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex, role C.int) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex, role int) *qt.QVariant, index *qt.QModelIndex, role int) *qt.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + slotval2 := (int)(role) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Data, slotval1, slotval2) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_TimerEvent(event *qt.QTimerEvent) { + + C.QPdfSearchModel_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnTimerEvent(slot func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) { + ok := C.QPdfSearchModel_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_timerEvent +func miqt_exec_callback_QPdfSearchModel_timerEvent(self *C.QPdfSearchModel, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QPdfSearchModel) callVirtualBase_Index(row int, column int, parent *qt.QModelIndex) *qt.QModelIndex { + + _goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfSearchModel_virtualbase_index(unsafe.Pointer(this.h), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfSearchModel) OnIndex(slot func(super func(row int, column int, parent *qt.QModelIndex) *qt.QModelIndex, row int, column int, parent *qt.QModelIndex) *qt.QModelIndex) { + ok := C.QPdfSearchModel_override_virtual_index(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_index +func miqt_exec_callback_QPdfSearchModel_index(self *C.QPdfSearchModel, cb C.intptr_t, row C.int, column C.int, parent *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, column int, parent *qt.QModelIndex) *qt.QModelIndex, row int, column int, parent *qt.QModelIndex) *qt.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(column) + + slotval3 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Index, slotval1, slotval2, slotval3) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_Sibling(row int, column int, idx *qt.QModelIndex) *qt.QModelIndex { + + _goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfSearchModel_virtualbase_sibling(unsafe.Pointer(this.h), (C.int)(row), (C.int)(column), (*C.QModelIndex)(idx.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfSearchModel) OnSibling(slot func(super func(row int, column int, idx *qt.QModelIndex) *qt.QModelIndex, row int, column int, idx *qt.QModelIndex) *qt.QModelIndex) { + ok := C.QPdfSearchModel_override_virtual_sibling(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_sibling +func miqt_exec_callback_QPdfSearchModel_sibling(self *C.QPdfSearchModel, cb C.intptr_t, row C.int, column C.int, idx *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, column int, idx *qt.QModelIndex) *qt.QModelIndex, row int, column int, idx *qt.QModelIndex) *qt.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(column) + + slotval3 := qt.UnsafeNewQModelIndex(unsafe.Pointer(idx)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Sibling, slotval1, slotval2, slotval3) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_DropMimeData(data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_dropMimeData(unsafe.Pointer(this.h), (*C.QMimeData)(data.UnsafePointer()), (C.int)(action), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnDropMimeData(slot func(super func(data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool, data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_dropMimeData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_dropMimeData +func miqt_exec_callback_QPdfSearchModel_dropMimeData(self *C.QPdfSearchModel, cb C.intptr_t, data *C.QMimeData, action C.int, row C.int, column C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool, data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMimeData(unsafe.Pointer(data)) + + slotval2 := (qt.DropAction)(action) + + slotval3 := (int)(row) + + slotval4 := (int)(column) + + slotval5 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_DropMimeData, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_Flags(index *qt.QModelIndex) qt.ItemFlag { + + return (qt.ItemFlag)(C.QPdfSearchModel_virtualbase_flags(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnFlags(slot func(super func(index *qt.QModelIndex) qt.ItemFlag, index *qt.QModelIndex) qt.ItemFlag) { + ok := C.QPdfSearchModel_override_virtual_flags(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_flags +func miqt_exec_callback_QPdfSearchModel_flags(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex) qt.ItemFlag, index *qt.QModelIndex) qt.ItemFlag) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Flags, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_SetData(index *qt.QModelIndex, value *qt.QVariant, role int) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_setData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), (*C.QVariant)(value.UnsafePointer()), (C.int)(role))) + +} +func (this *QPdfSearchModel) OnSetData(slot func(super func(index *qt.QModelIndex, value *qt.QVariant, role int) bool, index *qt.QModelIndex, value *qt.QVariant, role int) bool) { + ok := C.QPdfSearchModel_override_virtual_setData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_setData +func miqt_exec_callback_QPdfSearchModel_setData(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex, value *C.QVariant, role C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex, value *qt.QVariant, role int) bool, index *qt.QModelIndex, value *qt.QVariant, role int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + slotval2 := qt.UnsafeNewQVariant(unsafe.Pointer(value)) + + slotval3 := (int)(role) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_SetData, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_HeaderData(section int, orientation qt.Orientation, role int) *qt.QVariant { + + _goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QPdfSearchModel_virtualbase_headerData(unsafe.Pointer(this.h), (C.int)(section), (C.int)(orientation), (C.int)(role)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfSearchModel) OnHeaderData(slot func(super func(section int, orientation qt.Orientation, role int) *qt.QVariant, section int, orientation qt.Orientation, role int) *qt.QVariant) { + ok := C.QPdfSearchModel_override_virtual_headerData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_headerData +func miqt_exec_callback_QPdfSearchModel_headerData(self *C.QPdfSearchModel, cb C.intptr_t, section C.int, orientation C.int, role C.int) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(section int, orientation qt.Orientation, role int) *qt.QVariant, section int, orientation qt.Orientation, role int) *qt.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(section) + + slotval2 := (qt.Orientation)(orientation) + + slotval3 := (int)(role) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_HeaderData, slotval1, slotval2, slotval3) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_SetHeaderData(section int, orientation qt.Orientation, value *qt.QVariant, role int) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_setHeaderData(unsafe.Pointer(this.h), (C.int)(section), (C.int)(orientation), (*C.QVariant)(value.UnsafePointer()), (C.int)(role))) + +} +func (this *QPdfSearchModel) OnSetHeaderData(slot func(super func(section int, orientation qt.Orientation, value *qt.QVariant, role int) bool, section int, orientation qt.Orientation, value *qt.QVariant, role int) bool) { + ok := C.QPdfSearchModel_override_virtual_setHeaderData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_setHeaderData +func miqt_exec_callback_QPdfSearchModel_setHeaderData(self *C.QPdfSearchModel, cb C.intptr_t, section C.int, orientation C.int, value *C.QVariant, role C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(section int, orientation qt.Orientation, value *qt.QVariant, role int) bool, section int, orientation qt.Orientation, value *qt.QVariant, role int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(section) + + slotval2 := (qt.Orientation)(orientation) + + slotval3 := qt.UnsafeNewQVariant(unsafe.Pointer(value)) + + slotval4 := (int)(role) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_SetHeaderData, slotval1, slotval2, slotval3, slotval4) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_ItemData(index *qt.QModelIndex) map[int]qt.QVariant { + + var _mm C.struct_miqt_map = C.QPdfSearchModel_virtualbase_itemData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())) + _ret := make(map[int]qt.QVariant, int(_mm.len)) + _Keys := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + _entry_Key := (int)(_Keys[i]) + + _mapval_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(_Values[i])) + _mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _entry_Value := *_mapval_goptr + + _ret[_entry_Key] = _entry_Value + } + return _ret + +} +func (this *QPdfSearchModel) OnItemData(slot func(super func(index *qt.QModelIndex) map[int]qt.QVariant, index *qt.QModelIndex) map[int]qt.QVariant) { + ok := C.QPdfSearchModel_override_virtual_itemData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_itemData +func miqt_exec_callback_QPdfSearchModel_itemData(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex) C.struct_miqt_map { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex) map[int]qt.QVariant, index *qt.QModelIndex) map[int]qt.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_ItemData, slotval1) + virtualReturn_Keys_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Keys_CArray)) + virtualReturn_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Values_CArray)) + virtualReturn_ctr := 0 + for virtualReturn_k, virtualReturn_v := range virtualReturn { + virtualReturn_Keys_CArray[virtualReturn_ctr] = (C.int)(virtualReturn_k) + virtualReturn_Values_CArray[virtualReturn_ctr] = (*C.QVariant)(virtualReturn_v.UnsafePointer()) + virtualReturn_ctr++ + } + virtualReturn_mm := C.struct_miqt_map{ + len: C.size_t(len(virtualReturn)), + keys: unsafe.Pointer(virtualReturn_Keys_CArray), + values: unsafe.Pointer(virtualReturn_Values_CArray), + } + + return virtualReturn_mm + +} + +func (this *QPdfSearchModel) callVirtualBase_SetItemData(index *qt.QModelIndex, roles map[int]qt.QVariant) bool { + roles_Keys_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(roles)))) + defer C.free(unsafe.Pointer(roles_Keys_CArray)) + roles_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(roles)))) + defer C.free(unsafe.Pointer(roles_Values_CArray)) + roles_ctr := 0 + for roles_k, roles_v := range roles { + roles_Keys_CArray[roles_ctr] = (C.int)(roles_k) + roles_Values_CArray[roles_ctr] = (*C.QVariant)(roles_v.UnsafePointer()) + roles_ctr++ + } + roles_mm := C.struct_miqt_map{ + len: C.size_t(len(roles)), + keys: unsafe.Pointer(roles_Keys_CArray), + values: unsafe.Pointer(roles_Values_CArray), + } + + return (bool)(C.QPdfSearchModel_virtualbase_setItemData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), roles_mm)) + +} +func (this *QPdfSearchModel) OnSetItemData(slot func(super func(index *qt.QModelIndex, roles map[int]qt.QVariant) bool, index *qt.QModelIndex, roles map[int]qt.QVariant) bool) { + ok := C.QPdfSearchModel_override_virtual_setItemData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_setItemData +func miqt_exec_callback_QPdfSearchModel_setItemData(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex, roles C.struct_miqt_map) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex, roles map[int]qt.QVariant) bool, index *qt.QModelIndex, roles map[int]qt.QVariant) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + var roles_mm C.struct_miqt_map = roles + roles_ret := make(map[int]qt.QVariant, int(roles_mm.len)) + roles_Keys := (*[0xffff]C.int)(unsafe.Pointer(roles_mm.keys)) + roles_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(roles_mm.values)) + for i := 0; i < int(roles_mm.len); i++ { + roles_entry_Key := (int)(roles_Keys[i]) + + roles_mapval_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(roles_Values[i])) + roles_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + roles_entry_Value := *roles_mapval_goptr + + roles_ret[roles_entry_Key] = roles_entry_Value + } + slotval2 := roles_ret + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_SetItemData, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_MimeTypes() []string { + + var _ma C.struct_miqt_array = C.QPdfSearchModel_virtualbase_mimeTypes(unsafe.Pointer(this.h)) + _ret := make([]string, int(_ma.len)) + _outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + var _lv_ms C.struct_miqt_string = _outCast[i] + _lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len))) + C.free(unsafe.Pointer(_lv_ms.data)) + _ret[i] = _lv_ret + } + return _ret + +} +func (this *QPdfSearchModel) OnMimeTypes(slot func(super func() []string) []string) { + ok := C.QPdfSearchModel_override_virtual_mimeTypes(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_mimeTypes +func miqt_exec_callback_QPdfSearchModel_mimeTypes(self *C.QPdfSearchModel, cb C.intptr_t) C.struct_miqt_array { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() []string) []string) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_MimeTypes) + virtualReturn_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_CArray)) + for i := range virtualReturn { + virtualReturn_i_ms := C.struct_miqt_string{} + virtualReturn_i_ms.data = C.CString(virtualReturn[i]) + virtualReturn_i_ms.len = C.size_t(len(virtualReturn[i])) + defer C.free(unsafe.Pointer(virtualReturn_i_ms.data)) + virtualReturn_CArray[i] = virtualReturn_i_ms + } + virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)} + + return virtualReturn_ma + +} + +func (this *QPdfSearchModel) callVirtualBase_MimeData(indexes []qt.QModelIndex) *qt.QMimeData { + indexes_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(indexes)))) + defer C.free(unsafe.Pointer(indexes_CArray)) + for i := range indexes { + indexes_CArray[i] = (*C.QModelIndex)(indexes[i].UnsafePointer()) + } + indexes_ma := C.struct_miqt_array{len: C.size_t(len(indexes)), data: unsafe.Pointer(indexes_CArray)} + + return qt.UnsafeNewQMimeData(unsafe.Pointer(C.QPdfSearchModel_virtualbase_mimeData(unsafe.Pointer(this.h), indexes_ma))) + +} +func (this *QPdfSearchModel) OnMimeData(slot func(super func(indexes []qt.QModelIndex) *qt.QMimeData, indexes []qt.QModelIndex) *qt.QMimeData) { + ok := C.QPdfSearchModel_override_virtual_mimeData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_mimeData +func miqt_exec_callback_QPdfSearchModel_mimeData(self *C.QPdfSearchModel, cb C.intptr_t, indexes C.struct_miqt_array) *C.QMimeData { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(indexes []qt.QModelIndex) *qt.QMimeData, indexes []qt.QModelIndex) *qt.QMimeData) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var indexes_ma C.struct_miqt_array = indexes + indexes_ret := make([]qt.QModelIndex, int(indexes_ma.len)) + indexes_outCast := (*[0xffff]*C.QModelIndex)(unsafe.Pointer(indexes_ma.data)) // hey ya + for i := 0; i < int(indexes_ma.len); i++ { + indexes_lv_goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(indexes_outCast[i])) + indexes_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + indexes_ret[i] = *indexes_lv_goptr + } + slotval1 := indexes_ret + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_MimeData, slotval1) + + return (*C.QMimeData)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_CanDropMimeData(data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_canDropMimeData(unsafe.Pointer(this.h), (*C.QMimeData)(data.UnsafePointer()), (C.int)(action), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnCanDropMimeData(slot func(super func(data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool, data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_canDropMimeData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_canDropMimeData +func miqt_exec_callback_QPdfSearchModel_canDropMimeData(self *C.QPdfSearchModel, cb C.intptr_t, data *C.QMimeData, action C.int, row C.int, column C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool, data *qt.QMimeData, action qt.DropAction, row int, column int, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMimeData(unsafe.Pointer(data)) + + slotval2 := (qt.DropAction)(action) + + slotval3 := (int)(row) + + slotval4 := (int)(column) + + slotval5 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_CanDropMimeData, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_SupportedDropActions() qt.DropAction { + + return (qt.DropAction)(C.QPdfSearchModel_virtualbase_supportedDropActions(unsafe.Pointer(this.h))) + +} +func (this *QPdfSearchModel) OnSupportedDropActions(slot func(super func() qt.DropAction) qt.DropAction) { + ok := C.QPdfSearchModel_override_virtual_supportedDropActions(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_supportedDropActions +func miqt_exec_callback_QPdfSearchModel_supportedDropActions(self *C.QPdfSearchModel, cb C.intptr_t) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() qt.DropAction) qt.DropAction) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_SupportedDropActions) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_SupportedDragActions() qt.DropAction { + + return (qt.DropAction)(C.QPdfSearchModel_virtualbase_supportedDragActions(unsafe.Pointer(this.h))) + +} +func (this *QPdfSearchModel) OnSupportedDragActions(slot func(super func() qt.DropAction) qt.DropAction) { + ok := C.QPdfSearchModel_override_virtual_supportedDragActions(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_supportedDragActions +func miqt_exec_callback_QPdfSearchModel_supportedDragActions(self *C.QPdfSearchModel, cb C.intptr_t) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() qt.DropAction) qt.DropAction) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_SupportedDragActions) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_InsertRows(row int, count int, parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_insertRows(unsafe.Pointer(this.h), (C.int)(row), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnInsertRows(slot func(super func(row int, count int, parent *qt.QModelIndex) bool, row int, count int, parent *qt.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_insertRows(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_insertRows +func miqt_exec_callback_QPdfSearchModel_insertRows(self *C.QPdfSearchModel, cb C.intptr_t, row C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, count int, parent *qt.QModelIndex) bool, row int, count int, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(count) + + slotval3 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_InsertRows, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_InsertColumns(column int, count int, parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_insertColumns(unsafe.Pointer(this.h), (C.int)(column), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnInsertColumns(slot func(super func(column int, count int, parent *qt.QModelIndex) bool, column int, count int, parent *qt.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_insertColumns(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_insertColumns +func miqt_exec_callback_QPdfSearchModel_insertColumns(self *C.QPdfSearchModel, cb C.intptr_t, column C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(column int, count int, parent *qt.QModelIndex) bool, column int, count int, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(column) + + slotval2 := (int)(count) + + slotval3 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_InsertColumns, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_RemoveRows(row int, count int, parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_removeRows(unsafe.Pointer(this.h), (C.int)(row), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnRemoveRows(slot func(super func(row int, count int, parent *qt.QModelIndex) bool, row int, count int, parent *qt.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_removeRows(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_removeRows +func miqt_exec_callback_QPdfSearchModel_removeRows(self *C.QPdfSearchModel, cb C.intptr_t, row C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, count int, parent *qt.QModelIndex) bool, row int, count int, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(count) + + slotval3 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_RemoveRows, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_RemoveColumns(column int, count int, parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_removeColumns(unsafe.Pointer(this.h), (C.int)(column), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnRemoveColumns(slot func(super func(column int, count int, parent *qt.QModelIndex) bool, column int, count int, parent *qt.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_removeColumns(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_removeColumns +func miqt_exec_callback_QPdfSearchModel_removeColumns(self *C.QPdfSearchModel, cb C.intptr_t, column C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(column int, count int, parent *qt.QModelIndex) bool, column int, count int, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(column) + + slotval2 := (int)(count) + + slotval3 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_RemoveColumns, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_MoveRows(sourceParent *qt.QModelIndex, sourceRow int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_moveRows(unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceRow), (C.int)(count), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationChild))) + +} +func (this *QPdfSearchModel) OnMoveRows(slot func(super func(sourceParent *qt.QModelIndex, sourceRow int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool, sourceParent *qt.QModelIndex, sourceRow int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool) { + ok := C.QPdfSearchModel_override_virtual_moveRows(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_moveRows +func miqt_exec_callback_QPdfSearchModel_moveRows(self *C.QPdfSearchModel, cb C.intptr_t, sourceParent *C.QModelIndex, sourceRow C.int, count C.int, destinationParent *C.QModelIndex, destinationChild C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(sourceParent *qt.QModelIndex, sourceRow int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool, sourceParent *qt.QModelIndex, sourceRow int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(sourceParent)) + + slotval2 := (int)(sourceRow) + + slotval3 := (int)(count) + + slotval4 := qt.UnsafeNewQModelIndex(unsafe.Pointer(destinationParent)) + + slotval5 := (int)(destinationChild) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_MoveRows, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_MoveColumns(sourceParent *qt.QModelIndex, sourceColumn int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_moveColumns(unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceColumn), (C.int)(count), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationChild))) + +} +func (this *QPdfSearchModel) OnMoveColumns(slot func(super func(sourceParent *qt.QModelIndex, sourceColumn int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool, sourceParent *qt.QModelIndex, sourceColumn int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool) { + ok := C.QPdfSearchModel_override_virtual_moveColumns(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_moveColumns +func miqt_exec_callback_QPdfSearchModel_moveColumns(self *C.QPdfSearchModel, cb C.intptr_t, sourceParent *C.QModelIndex, sourceColumn C.int, count C.int, destinationParent *C.QModelIndex, destinationChild C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(sourceParent *qt.QModelIndex, sourceColumn int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool, sourceParent *qt.QModelIndex, sourceColumn int, count int, destinationParent *qt.QModelIndex, destinationChild int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(sourceParent)) + + slotval2 := (int)(sourceColumn) + + slotval3 := (int)(count) + + slotval4 := qt.UnsafeNewQModelIndex(unsafe.Pointer(destinationParent)) + + slotval5 := (int)(destinationChild) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_MoveColumns, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_FetchMore(parent *qt.QModelIndex) { + + C.QPdfSearchModel_virtualbase_fetchMore(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnFetchMore(slot func(super func(parent *qt.QModelIndex), parent *qt.QModelIndex)) { + ok := C.QPdfSearchModel_override_virtual_fetchMore(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_fetchMore +func miqt_exec_callback_QPdfSearchModel_fetchMore(self *C.QPdfSearchModel, cb C.intptr_t, parent *C.QModelIndex) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt.QModelIndex), parent *qt.QModelIndex)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_FetchMore, slotval1) + +} + +func (this *QPdfSearchModel) callVirtualBase_CanFetchMore(parent *qt.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_canFetchMore(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnCanFetchMore(slot func(super func(parent *qt.QModelIndex) bool, parent *qt.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_canFetchMore(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_canFetchMore +func miqt_exec_callback_QPdfSearchModel_canFetchMore(self *C.QPdfSearchModel, cb C.intptr_t, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt.QModelIndex) bool, parent *qt.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_CanFetchMore, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_Sort(column int, order qt.SortOrder) { + + C.QPdfSearchModel_virtualbase_sort(unsafe.Pointer(this.h), (C.int)(column), (C.int)(order)) + +} +func (this *QPdfSearchModel) OnSort(slot func(super func(column int, order qt.SortOrder), column int, order qt.SortOrder)) { + ok := C.QPdfSearchModel_override_virtual_sort(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_sort +func miqt_exec_callback_QPdfSearchModel_sort(self *C.QPdfSearchModel, cb C.intptr_t, column C.int, order C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(column int, order qt.SortOrder), column int, order qt.SortOrder)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(column) + + slotval2 := (qt.SortOrder)(order) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Sort, slotval1, slotval2) + +} + +func (this *QPdfSearchModel) callVirtualBase_Buddy(index *qt.QModelIndex) *qt.QModelIndex { + + _goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfSearchModel_virtualbase_buddy(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfSearchModel) OnBuddy(slot func(super func(index *qt.QModelIndex) *qt.QModelIndex, index *qt.QModelIndex) *qt.QModelIndex) { + ok := C.QPdfSearchModel_override_virtual_buddy(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_buddy +func miqt_exec_callback_QPdfSearchModel_buddy(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex) *qt.QModelIndex, index *qt.QModelIndex) *qt.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Buddy, slotval1) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_Match(start *qt.QModelIndex, role int, value *qt.QVariant, hits int, flags qt.MatchFlag) []qt.QModelIndex { + + var _ma C.struct_miqt_array = C.QPdfSearchModel_virtualbase_match(unsafe.Pointer(this.h), (*C.QModelIndex)(start.UnsafePointer()), (C.int)(role), (*C.QVariant)(value.UnsafePointer()), (C.int)(hits), (C.int)(flags)) + _ret := make([]qt.QModelIndex, int(_ma.len)) + _outCast := (*[0xffff]*C.QModelIndex)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt.UnsafeNewQModelIndex(unsafe.Pointer(_outCast[i])) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret + +} +func (this *QPdfSearchModel) OnMatch(slot func(super func(start *qt.QModelIndex, role int, value *qt.QVariant, hits int, flags qt.MatchFlag) []qt.QModelIndex, start *qt.QModelIndex, role int, value *qt.QVariant, hits int, flags qt.MatchFlag) []qt.QModelIndex) { + ok := C.QPdfSearchModel_override_virtual_match(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_match +func miqt_exec_callback_QPdfSearchModel_match(self *C.QPdfSearchModel, cb C.intptr_t, start *C.QModelIndex, role C.int, value *C.QVariant, hits C.int, flags C.int) C.struct_miqt_array { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(start *qt.QModelIndex, role int, value *qt.QVariant, hits int, flags qt.MatchFlag) []qt.QModelIndex, start *qt.QModelIndex, role int, value *qt.QVariant, hits int, flags qt.MatchFlag) []qt.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(start)) + + slotval2 := (int)(role) + + slotval3 := qt.UnsafeNewQVariant(unsafe.Pointer(value)) + + slotval4 := (int)(hits) + + slotval5 := (qt.MatchFlag)(flags) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Match, slotval1, slotval2, slotval3, slotval4, slotval5) + virtualReturn_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_CArray)) + for i := range virtualReturn { + virtualReturn_CArray[i] = (*C.QModelIndex)(virtualReturn[i].UnsafePointer()) + } + virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)} + + return virtualReturn_ma + +} + +func (this *QPdfSearchModel) callVirtualBase_Span(index *qt.QModelIndex) *qt.QSize { + + _goptr := qt.UnsafeNewQSize(unsafe.Pointer(C.QPdfSearchModel_virtualbase_span(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfSearchModel) OnSpan(slot func(super func(index *qt.QModelIndex) *qt.QSize, index *qt.QModelIndex) *qt.QSize) { + ok := C.QPdfSearchModel_override_virtual_span(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_span +func miqt_exec_callback_QPdfSearchModel_span(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex) *C.QSize { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt.QModelIndex) *qt.QSize, index *qt.QModelIndex) *qt.QSize) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Span, slotval1) + + return (*C.QSize)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_Submit() bool { + + return (bool)(C.QPdfSearchModel_virtualbase_submit(unsafe.Pointer(this.h))) + +} +func (this *QPdfSearchModel) OnSubmit(slot func(super func() bool) bool) { + ok := C.QPdfSearchModel_override_virtual_submit(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_submit +func miqt_exec_callback_QPdfSearchModel_submit(self *C.QPdfSearchModel, cb C.intptr_t) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Submit) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_Revert() { + + C.QPdfSearchModel_virtualbase_revert(unsafe.Pointer(this.h)) + +} +func (this *QPdfSearchModel) OnRevert(slot func(super func())) { + ok := C.QPdfSearchModel_override_virtual_revert(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_revert +func miqt_exec_callback_QPdfSearchModel_revert(self *C.QPdfSearchModel, cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func())) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Revert) + +} + +func (this *QPdfSearchModel) callVirtualBase_Event(event *qt.QEvent) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnEvent(slot func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) { + ok := C.QPdfSearchModel_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_event +func miqt_exec_callback_QPdfSearchModel_event(self *C.QPdfSearchModel, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_EventFilter(watched *qt.QObject, event *qt.QEvent) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnEventFilter(slot func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) { + ok := C.QPdfSearchModel_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_eventFilter +func miqt_exec_callback_QPdfSearchModel_eventFilter(self *C.QPdfSearchModel, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_ChildEvent(event *qt.QChildEvent) { + + C.QPdfSearchModel_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnChildEvent(slot func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) { + ok := C.QPdfSearchModel_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_childEvent +func miqt_exec_callback_QPdfSearchModel_childEvent(self *C.QPdfSearchModel, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QPdfSearchModel) callVirtualBase_CustomEvent(event *qt.QEvent) { + + C.QPdfSearchModel_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnCustomEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) { + ok := C.QPdfSearchModel_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_customEvent +func miqt_exec_callback_QPdfSearchModel_customEvent(self *C.QPdfSearchModel, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QPdfSearchModel) callVirtualBase_ConnectNotify(signal *qt.QMetaMethod) { + + C.QPdfSearchModel_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnConnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QPdfSearchModel_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_connectNotify +func miqt_exec_callback_QPdfSearchModel_connectNotify(self *C.QPdfSearchModel, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QPdfSearchModel) callVirtualBase_DisconnectNotify(signal *qt.QMetaMethod) { + + C.QPdfSearchModel_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnDisconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QPdfSearchModel_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_disconnectNotify +func miqt_exec_callback_QPdfSearchModel_disconnectNotify(self *C.QPdfSearchModel, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QPdfSearchModel) Delete() { + C.QPdfSearchModel_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfSearchModel) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfSearchModel) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/pdf/gen_qpdfsearchmodel.h b/qt/pdf/gen_qpdfsearchmodel.h new file mode 100644 index 00000000..bb160283 --- /dev/null +++ b/qt/pdf/gen_qpdfsearchmodel.h @@ -0,0 +1,186 @@ +#pragma once +#ifndef MIQT_QT_PDF_GEN_QPDFSEARCHMODEL_H +#define MIQT_QT_PDF_GEN_QPDFSEARCHMODEL_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractItemModel; +class QAbstractListModel; +class QChildEvent; +class QDataStream; +class QEvent; +class QMetaMethod; +class QMetaObject; +class QMimeData; +class QModelIndex; +class QObject; +class QPdfDocument; +class QPdfSearchModel; +class QPdfSearchResult; +class QSize; +class QTimerEvent; +class QVariant; +#else +typedef struct QAbstractItemModel QAbstractItemModel; +typedef struct QAbstractListModel QAbstractListModel; +typedef struct QChildEvent QChildEvent; +typedef struct QDataStream QDataStream; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QMimeData QMimeData; +typedef struct QModelIndex QModelIndex; +typedef struct QObject QObject; +typedef struct QPdfDocument QPdfDocument; +typedef struct QPdfSearchModel QPdfSearchModel; +typedef struct QPdfSearchResult QPdfSearchResult; +typedef struct QSize QSize; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +#endif + +QPdfSearchModel* QPdfSearchModel_new(); +QPdfSearchModel* QPdfSearchModel_new2(QObject* parent); +void QPdfSearchModel_virtbase(QPdfSearchModel* src, QAbstractListModel** outptr_QAbstractListModel); +QMetaObject* QPdfSearchModel_metaObject(const QPdfSearchModel* self); +void* QPdfSearchModel_metacast(QPdfSearchModel* self, const char* param1); +struct miqt_string QPdfSearchModel_tr(const char* s); +struct miqt_string QPdfSearchModel_trUtf8(const char* s); +struct miqt_array /* of QPdfSearchResult* */ QPdfSearchModel_resultsOnPage(const QPdfSearchModel* self, int page); +QPdfSearchResult* QPdfSearchModel_resultAtIndex(const QPdfSearchModel* self, int index); +QPdfDocument* QPdfSearchModel_document(const QPdfSearchModel* self); +struct miqt_string QPdfSearchModel_searchString(const QPdfSearchModel* self); +struct miqt_map /* of int to struct miqt_string */ QPdfSearchModel_roleNames(const QPdfSearchModel* self); +int QPdfSearchModel_rowCount(const QPdfSearchModel* self, QModelIndex* parent); +QVariant* QPdfSearchModel_data(const QPdfSearchModel* self, QModelIndex* index, int role); +void QPdfSearchModel_setSearchString(QPdfSearchModel* self, struct miqt_string searchString); +void QPdfSearchModel_setDocument(QPdfSearchModel* self, QPdfDocument* document); +void QPdfSearchModel_documentChanged(QPdfSearchModel* self); +void QPdfSearchModel_connect_documentChanged(QPdfSearchModel* self, intptr_t slot); +void QPdfSearchModel_searchStringChanged(QPdfSearchModel* self); +void QPdfSearchModel_connect_searchStringChanged(QPdfSearchModel* self, intptr_t slot); +void QPdfSearchModel_timerEvent(QPdfSearchModel* self, QTimerEvent* event); +struct miqt_string QPdfSearchModel_tr2(const char* s, const char* c); +struct miqt_string QPdfSearchModel_tr3(const char* s, const char* c, int n); +struct miqt_string QPdfSearchModel_trUtf82(const char* s, const char* c); +struct miqt_string QPdfSearchModel_trUtf83(const char* s, const char* c, int n); +bool QPdfSearchModel_override_virtual_roleNames(void* self, intptr_t slot); +struct miqt_map /* of int to struct miqt_string */ QPdfSearchModel_virtualbase_roleNames(const void* self); +bool QPdfSearchModel_override_virtual_rowCount(void* self, intptr_t slot); +int QPdfSearchModel_virtualbase_rowCount(const void* self, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_data(void* self, intptr_t slot); +QVariant* QPdfSearchModel_virtualbase_data(const void* self, QModelIndex* index, int role); +bool QPdfSearchModel_override_virtual_timerEvent(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QPdfSearchModel_override_virtual_index(void* self, intptr_t slot); +QModelIndex* QPdfSearchModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_sibling(void* self, intptr_t slot); +QModelIndex* QPdfSearchModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx); +bool QPdfSearchModel_override_virtual_dropMimeData(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_flags(void* self, intptr_t slot); +int QPdfSearchModel_virtualbase_flags(const void* self, QModelIndex* index); +bool QPdfSearchModel_override_virtual_setData(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role); +bool QPdfSearchModel_override_virtual_headerData(void* self, intptr_t slot); +QVariant* QPdfSearchModel_virtualbase_headerData(const void* self, int section, int orientation, int role); +bool QPdfSearchModel_override_virtual_setHeaderData(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role); +bool QPdfSearchModel_override_virtual_itemData(void* self, intptr_t slot); +struct miqt_map /* of int to QVariant* */ QPdfSearchModel_virtualbase_itemData(const void* self, QModelIndex* index); +bool QPdfSearchModel_override_virtual_setItemData(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */ roles); +bool QPdfSearchModel_override_virtual_mimeTypes(void* self, intptr_t slot); +struct miqt_array /* of struct miqt_string */ QPdfSearchModel_virtualbase_mimeTypes(const void* self); +bool QPdfSearchModel_override_virtual_mimeData(void* self, intptr_t slot); +QMimeData* QPdfSearchModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes); +bool QPdfSearchModel_override_virtual_canDropMimeData(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_supportedDropActions(void* self, intptr_t slot); +int QPdfSearchModel_virtualbase_supportedDropActions(const void* self); +bool QPdfSearchModel_override_virtual_supportedDragActions(void* self, intptr_t slot); +int QPdfSearchModel_virtualbase_supportedDragActions(const void* self); +bool QPdfSearchModel_override_virtual_insertRows(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_insertColumns(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_removeRows(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_removeColumns(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_moveRows(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild); +bool QPdfSearchModel_override_virtual_moveColumns(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild); +bool QPdfSearchModel_override_virtual_fetchMore(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_fetchMore(void* self, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_canFetchMore(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_sort(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_sort(void* self, int column, int order); +bool QPdfSearchModel_override_virtual_buddy(void* self, intptr_t slot); +QModelIndex* QPdfSearchModel_virtualbase_buddy(const void* self, QModelIndex* index); +bool QPdfSearchModel_override_virtual_match(void* self, intptr_t slot); +struct miqt_array /* of QModelIndex* */ QPdfSearchModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); +bool QPdfSearchModel_override_virtual_span(void* self, intptr_t slot); +QSize* QPdfSearchModel_virtualbase_span(const void* self, QModelIndex* index); +bool QPdfSearchModel_override_virtual_submit(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_submit(void* self); +bool QPdfSearchModel_override_virtual_revert(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_revert(void* self); +bool QPdfSearchModel_override_virtual_event(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_event(void* self, QEvent* event); +bool QPdfSearchModel_override_virtual_eventFilter(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QPdfSearchModel_override_virtual_childEvent(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_childEvent(void* self, QChildEvent* event); +bool QPdfSearchModel_override_virtual_customEvent(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_customEvent(void* self, QEvent* event); +bool QPdfSearchModel_override_virtual_connectNotify(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QPdfSearchModel_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); +void QPdfSearchModel_protectedbase_updatePage(bool* _dynamic_cast_ok, void* self, int page); +void QPdfSearchModel_protectedbase_resetInternalData(bool* _dynamic_cast_ok, void* self); +QModelIndex* QPdfSearchModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column); +void QPdfSearchModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */ indexes, QDataStream* stream); +bool QPdfSearchModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream); +void QPdfSearchModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfSearchModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self); +void QPdfSearchModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfSearchModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self); +bool QPdfSearchModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow); +void QPdfSearchModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self); +void QPdfSearchModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfSearchModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self); +void QPdfSearchModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfSearchModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self); +bool QPdfSearchModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn); +void QPdfSearchModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self); +void QPdfSearchModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self); +void QPdfSearchModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self); +void QPdfSearchModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to); +void QPdfSearchModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */ from, struct miqt_array /* of QModelIndex* */ to); +struct miqt_array /* of QModelIndex* */ QPdfSearchModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self); +QObject* QPdfSearchModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QPdfSearchModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QPdfSearchModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QPdfSearchModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +void QPdfSearchModel_delete(QPdfSearchModel* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/pdf/gen_qpdfsearchresult.cpp b/qt/pdf/gen_qpdfsearchresult.cpp new file mode 100644 index 00000000..26486add --- /dev/null +++ b/qt/pdf/gen_qpdfsearchresult.cpp @@ -0,0 +1,69 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qpdfsearchresult.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +QPdfSearchResult* QPdfSearchResult_new() { + return new QPdfSearchResult(); +} + +QPdfSearchResult* QPdfSearchResult_new2(QPdfSearchResult* param1) { + return new QPdfSearchResult(*param1); +} + +void QPdfSearchResult_virtbase(QPdfSearchResult* src, QPdfDestination** outptr_QPdfDestination) { + *outptr_QPdfDestination = static_cast(src); +} + +struct miqt_string QPdfSearchResult_contextBefore(const QPdfSearchResult* self) { + QString _ret = self->contextBefore(); + // 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 QPdfSearchResult_contextAfter(const QPdfSearchResult* self) { + QString _ret = self->contextAfter(); + // 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_array /* of QRectF* */ QPdfSearchResult_rectangles(const QPdfSearchResult* self) { + QVector _ret = self->rectangles(); + // Convert QList<> from C++ memory to manually-managed C memory + QRectF** _arr = static_cast(malloc(sizeof(QRectF*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QRectF(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +void QPdfSearchResult_delete(QPdfSearchResult* self) { + delete self; +} + diff --git a/qt/pdf/gen_qpdfsearchresult.go b/qt/pdf/gen_qpdfsearchresult.go new file mode 100644 index 00000000..fab85e35 --- /dev/null +++ b/qt/pdf/gen_qpdfsearchresult.go @@ -0,0 +1,103 @@ +package pdf + +/* + +#include "gen_qpdfsearchresult.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "runtime" + "unsafe" +) + +type QPdfSearchResult struct { + h *C.QPdfSearchResult + *QPdfDestination +} + +func (this *QPdfSearchResult) cPointer() *C.QPdfSearchResult { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfSearchResult) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfSearchResult constructs the type using only CGO pointers. +func newQPdfSearchResult(h *C.QPdfSearchResult) *QPdfSearchResult { + if h == nil { + return nil + } + var outptr_QPdfDestination *C.QPdfDestination = nil + C.QPdfSearchResult_virtbase(h, &outptr_QPdfDestination) + + return &QPdfSearchResult{h: h, + QPdfDestination: newQPdfDestination(outptr_QPdfDestination)} +} + +// UnsafeNewQPdfSearchResult constructs the type using only unsafe pointers. +func UnsafeNewQPdfSearchResult(h unsafe.Pointer) *QPdfSearchResult { + return newQPdfSearchResult((*C.QPdfSearchResult)(h)) +} + +// NewQPdfSearchResult constructs a new QPdfSearchResult object. +func NewQPdfSearchResult() *QPdfSearchResult { + + return newQPdfSearchResult(C.QPdfSearchResult_new()) +} + +// NewQPdfSearchResult2 constructs a new QPdfSearchResult object. +func NewQPdfSearchResult2(param1 *QPdfSearchResult) *QPdfSearchResult { + + return newQPdfSearchResult(C.QPdfSearchResult_new2(param1.cPointer())) +} + +func (this *QPdfSearchResult) ContextBefore() string { + var _ms C.struct_miqt_string = C.QPdfSearchResult_contextBefore(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfSearchResult) ContextAfter() string { + var _ms C.struct_miqt_string = C.QPdfSearchResult_contextAfter(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfSearchResult) Rectangles() []qt.QRectF { + var _ma C.struct_miqt_array = C.QPdfSearchResult_rectangles(this.h) + _ret := make([]qt.QRectF, int(_ma.len)) + _outCast := (*[0xffff]*C.QRectF)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _vv_goptr := qt.UnsafeNewQRectF(unsafe.Pointer(_outCast[i])) + _vv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_vv_goptr + } + return _ret +} + +// Delete this object from C++ memory. +func (this *QPdfSearchResult) Delete() { + C.QPdfSearchResult_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfSearchResult) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfSearchResult) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/pdf/gen_qpdfsearchresult.h b/qt/pdf/gen_qpdfsearchresult.h new file mode 100644 index 00000000..1e7798a6 --- /dev/null +++ b/qt/pdf/gen_qpdfsearchresult.h @@ -0,0 +1,39 @@ +#pragma once +#ifndef MIQT_QT_PDF_GEN_QPDFSEARCHRESULT_H +#define MIQT_QT_PDF_GEN_QPDFSEARCHRESULT_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QPdfDestination; +class QPdfSearchResult; +class QRectF; +#else +typedef struct QPdfDestination QPdfDestination; +typedef struct QPdfSearchResult QPdfSearchResult; +typedef struct QRectF QRectF; +#endif + +QPdfSearchResult* QPdfSearchResult_new(); +QPdfSearchResult* QPdfSearchResult_new2(QPdfSearchResult* param1); +void QPdfSearchResult_virtbase(QPdfSearchResult* src, QPdfDestination** outptr_QPdfDestination); +struct miqt_string QPdfSearchResult_contextBefore(const QPdfSearchResult* self); +struct miqt_string QPdfSearchResult_contextAfter(const QPdfSearchResult* self); +struct miqt_array /* of QRectF* */ QPdfSearchResult_rectangles(const QPdfSearchResult* self); +void QPdfSearchResult_delete(QPdfSearchResult* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/pdf/gen_qpdfselection.cpp b/qt/pdf/gen_qpdfselection.cpp new file mode 100644 index 00000000..6760580f --- /dev/null +++ b/qt/pdf/gen_qpdfselection.cpp @@ -0,0 +1,67 @@ +#include +#include +#include +#include +#include +#include +#include "gen_qpdfselection.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +QPdfSelection* QPdfSelection_new(QPdfSelection* other) { + return new QPdfSelection(*other); +} + +void QPdfSelection_operatorAssign(QPdfSelection* self, QPdfSelection* other) { + self->operator=(*other); +} + +void QPdfSelection_swap(QPdfSelection* self, QPdfSelection* other) { + self->swap(*other); +} + +bool QPdfSelection_isValid(const QPdfSelection* self) { + return self->isValid(); +} + +struct miqt_string QPdfSelection_text(const QPdfSelection* self) { + QString _ret = self->text(); + // 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; +} + +QRectF* QPdfSelection_boundingRectangle(const QPdfSelection* self) { + return new QRectF(self->boundingRectangle()); +} + +int QPdfSelection_startIndex(const QPdfSelection* self) { + return self->startIndex(); +} + +int QPdfSelection_endIndex(const QPdfSelection* self) { + return self->endIndex(); +} + +void QPdfSelection_copyToClipboard(const QPdfSelection* self) { + self->copyToClipboard(); +} + +void QPdfSelection_copyToClipboardWithMode(const QPdfSelection* self, int mode) { + self->copyToClipboard(static_cast(mode)); +} + +void QPdfSelection_delete(QPdfSelection* self) { + delete self; +} + diff --git a/qt/pdf/gen_qpdfselection.go b/qt/pdf/gen_qpdfselection.go new file mode 100644 index 00000000..4cdbdb27 --- /dev/null +++ b/qt/pdf/gen_qpdfselection.go @@ -0,0 +1,108 @@ +package pdf + +/* + +#include "gen_qpdfselection.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "runtime" + "unsafe" +) + +type QPdfSelection struct { + h *C.QPdfSelection +} + +func (this *QPdfSelection) cPointer() *C.QPdfSelection { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfSelection) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfSelection constructs the type using only CGO pointers. +func newQPdfSelection(h *C.QPdfSelection) *QPdfSelection { + if h == nil { + return nil + } + + return &QPdfSelection{h: h} +} + +// UnsafeNewQPdfSelection constructs the type using only unsafe pointers. +func UnsafeNewQPdfSelection(h unsafe.Pointer) *QPdfSelection { + return newQPdfSelection((*C.QPdfSelection)(h)) +} + +// NewQPdfSelection constructs a new QPdfSelection object. +func NewQPdfSelection(other *QPdfSelection) *QPdfSelection { + + return newQPdfSelection(C.QPdfSelection_new(other.cPointer())) +} + +func (this *QPdfSelection) OperatorAssign(other *QPdfSelection) { + C.QPdfSelection_operatorAssign(this.h, other.cPointer()) +} + +func (this *QPdfSelection) Swap(other *QPdfSelection) { + C.QPdfSelection_swap(this.h, other.cPointer()) +} + +func (this *QPdfSelection) IsValid() bool { + return (bool)(C.QPdfSelection_isValid(this.h)) +} + +func (this *QPdfSelection) Text() string { + var _ms C.struct_miqt_string = C.QPdfSelection_text(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfSelection) BoundingRectangle() *qt.QRectF { + _goptr := qt.UnsafeNewQRectF(unsafe.Pointer(C.QPdfSelection_boundingRectangle(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfSelection) StartIndex() int { + return (int)(C.QPdfSelection_startIndex(this.h)) +} + +func (this *QPdfSelection) EndIndex() int { + return (int)(C.QPdfSelection_endIndex(this.h)) +} + +func (this *QPdfSelection) CopyToClipboard() { + C.QPdfSelection_copyToClipboard(this.h) +} + +func (this *QPdfSelection) CopyToClipboardWithMode(mode qt.QClipboard__Mode) { + C.QPdfSelection_copyToClipboardWithMode(this.h, (C.int)(mode)) +} + +// Delete this object from C++ memory. +func (this *QPdfSelection) Delete() { + C.QPdfSelection_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfSelection) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfSelection) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/pdf/gen_qpdfselection.h b/qt/pdf/gen_qpdfselection.h new file mode 100644 index 00000000..b23ca387 --- /dev/null +++ b/qt/pdf/gen_qpdfselection.h @@ -0,0 +1,41 @@ +#pragma once +#ifndef MIQT_QT_PDF_GEN_QPDFSELECTION_H +#define MIQT_QT_PDF_GEN_QPDFSELECTION_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QPdfSelection; +class QRectF; +#else +typedef struct QPdfSelection QPdfSelection; +typedef struct QRectF QRectF; +#endif + +QPdfSelection* QPdfSelection_new(QPdfSelection* other); +void QPdfSelection_operatorAssign(QPdfSelection* self, QPdfSelection* other); +void QPdfSelection_swap(QPdfSelection* self, QPdfSelection* other); +bool QPdfSelection_isValid(const QPdfSelection* self); +struct miqt_string QPdfSelection_text(const QPdfSelection* self); +QRectF* QPdfSelection_boundingRectangle(const QPdfSelection* self); +int QPdfSelection_startIndex(const QPdfSelection* self); +int QPdfSelection_endIndex(const QPdfSelection* self); +void QPdfSelection_copyToClipboard(const QPdfSelection* self); +void QPdfSelection_copyToClipboardWithMode(const QPdfSelection* self, int mode); +void QPdfSelection_delete(QPdfSelection* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/pdf/gen_qpdfview.cpp b/qt/pdf/gen_qpdfview.cpp new file mode 100644 index 00000000..c9395ce5 --- /dev/null +++ b/qt/pdf/gen_qpdfview.cpp @@ -0,0 +1,2295 @@ +#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 +#include +#include +#include +#include +#include +#include +#include "gen_qpdfview.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QPdfView_documentChanged(intptr_t, QPdfDocument*); +void miqt_exec_callback_QPdfView_pageModeChanged(intptr_t, int); +void miqt_exec_callback_QPdfView_zoomModeChanged(intptr_t, int); +void miqt_exec_callback_QPdfView_zoomFactorChanged(intptr_t, double); +void miqt_exec_callback_QPdfView_pageSpacingChanged(intptr_t, int); +void miqt_exec_callback_QPdfView_documentMarginsChanged(intptr_t, QMargins*); +void miqt_exec_callback_QPdfView_paintEvent(QPdfView*, intptr_t, QPaintEvent*); +void miqt_exec_callback_QPdfView_resizeEvent(QPdfView*, intptr_t, QResizeEvent*); +void miqt_exec_callback_QPdfView_scrollContentsBy(QPdfView*, intptr_t, int, int); +QSize* miqt_exec_callback_QPdfView_minimumSizeHint(const QPdfView*, intptr_t); +QSize* miqt_exec_callback_QPdfView_sizeHint(const QPdfView*, intptr_t); +void miqt_exec_callback_QPdfView_setupViewport(QPdfView*, intptr_t, QWidget*); +bool miqt_exec_callback_QPdfView_eventFilter(QPdfView*, intptr_t, QObject*, QEvent*); +bool miqt_exec_callback_QPdfView_event(QPdfView*, intptr_t, QEvent*); +bool miqt_exec_callback_QPdfView_viewportEvent(QPdfView*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfView_mousePressEvent(QPdfView*, intptr_t, QMouseEvent*); +void miqt_exec_callback_QPdfView_mouseReleaseEvent(QPdfView*, intptr_t, QMouseEvent*); +void miqt_exec_callback_QPdfView_mouseDoubleClickEvent(QPdfView*, intptr_t, QMouseEvent*); +void miqt_exec_callback_QPdfView_mouseMoveEvent(QPdfView*, intptr_t, QMouseEvent*); +void miqt_exec_callback_QPdfView_wheelEvent(QPdfView*, intptr_t, QWheelEvent*); +void miqt_exec_callback_QPdfView_contextMenuEvent(QPdfView*, intptr_t, QContextMenuEvent*); +void miqt_exec_callback_QPdfView_dragEnterEvent(QPdfView*, intptr_t, QDragEnterEvent*); +void miqt_exec_callback_QPdfView_dragMoveEvent(QPdfView*, intptr_t, QDragMoveEvent*); +void miqt_exec_callback_QPdfView_dragLeaveEvent(QPdfView*, intptr_t, QDragLeaveEvent*); +void miqt_exec_callback_QPdfView_dropEvent(QPdfView*, intptr_t, QDropEvent*); +void miqt_exec_callback_QPdfView_keyPressEvent(QPdfView*, intptr_t, QKeyEvent*); +QSize* miqt_exec_callback_QPdfView_viewportSizeHint(const QPdfView*, intptr_t); +void miqt_exec_callback_QPdfView_changeEvent(QPdfView*, intptr_t, QEvent*); +int miqt_exec_callback_QPdfView_devType(const QPdfView*, intptr_t); +void miqt_exec_callback_QPdfView_setVisible(QPdfView*, intptr_t, bool); +int miqt_exec_callback_QPdfView_heightForWidth(const QPdfView*, intptr_t, int); +bool miqt_exec_callback_QPdfView_hasHeightForWidth(const QPdfView*, intptr_t); +QPaintEngine* miqt_exec_callback_QPdfView_paintEngine(const QPdfView*, intptr_t); +void miqt_exec_callback_QPdfView_keyReleaseEvent(QPdfView*, intptr_t, QKeyEvent*); +void miqt_exec_callback_QPdfView_focusInEvent(QPdfView*, intptr_t, QFocusEvent*); +void miqt_exec_callback_QPdfView_focusOutEvent(QPdfView*, intptr_t, QFocusEvent*); +void miqt_exec_callback_QPdfView_enterEvent(QPdfView*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfView_leaveEvent(QPdfView*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfView_moveEvent(QPdfView*, intptr_t, QMoveEvent*); +void miqt_exec_callback_QPdfView_closeEvent(QPdfView*, intptr_t, QCloseEvent*); +void miqt_exec_callback_QPdfView_tabletEvent(QPdfView*, intptr_t, QTabletEvent*); +void miqt_exec_callback_QPdfView_actionEvent(QPdfView*, intptr_t, QActionEvent*); +void miqt_exec_callback_QPdfView_showEvent(QPdfView*, intptr_t, QShowEvent*); +void miqt_exec_callback_QPdfView_hideEvent(QPdfView*, intptr_t, QHideEvent*); +bool miqt_exec_callback_QPdfView_nativeEvent(QPdfView*, intptr_t, struct miqt_string, void*, long*); +int miqt_exec_callback_QPdfView_metric(const QPdfView*, intptr_t, int); +void miqt_exec_callback_QPdfView_initPainter(const QPdfView*, intptr_t, QPainter*); +QPaintDevice* miqt_exec_callback_QPdfView_redirected(const QPdfView*, intptr_t, QPoint*); +QPainter* miqt_exec_callback_QPdfView_sharedPainter(const QPdfView*, intptr_t); +void miqt_exec_callback_QPdfView_inputMethodEvent(QPdfView*, intptr_t, QInputMethodEvent*); +QVariant* miqt_exec_callback_QPdfView_inputMethodQuery(const QPdfView*, intptr_t, int); +bool miqt_exec_callback_QPdfView_focusNextPrevChild(QPdfView*, intptr_t, bool); +void miqt_exec_callback_QPdfView_timerEvent(QPdfView*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QPdfView_childEvent(QPdfView*, intptr_t, QChildEvent*); +void miqt_exec_callback_QPdfView_customEvent(QPdfView*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfView_connectNotify(QPdfView*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QPdfView_disconnectNotify(QPdfView*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQPdfView final : public QPdfView { +public: + + MiqtVirtualQPdfView(QWidget* parent): QPdfView(parent) {}; + MiqtVirtualQPdfView(): QPdfView() {}; + + virtual ~MiqtVirtualQPdfView() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__paintEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void paintEvent(QPaintEvent* event) override { + if (handle__paintEvent == 0) { + QPdfView::paintEvent(event); + return; + } + + QPaintEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_paintEvent(this, handle__paintEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_paintEvent(void* self, QPaintEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__resizeEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void resizeEvent(QResizeEvent* event) override { + if (handle__resizeEvent == 0) { + QPdfView::resizeEvent(event); + return; + } + + QResizeEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_resizeEvent(this, handle__resizeEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_resizeEvent(void* self, QResizeEvent* event); + + // 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) { + QPdfView::scrollContentsBy(dx, dy); + return; + } + + int sigval1 = dx; + int sigval2 = dy; + + miqt_exec_callback_QPdfView_scrollContentsBy(this, handle__scrollContentsBy, sigval1, sigval2); + + + } + + friend void QPdfView_virtualbase_scrollContentsBy(void* self, int dx, int dy); + + // cgo.Handle value for overwritten implementation + intptr_t handle__minimumSizeHint = 0; + + // Subclass to allow providing a Go implementation + virtual QSize minimumSizeHint() const override { + if (handle__minimumSizeHint == 0) { + return QPdfView::minimumSizeHint(); + } + + + QSize* callback_return_value = miqt_exec_callback_QPdfView_minimumSizeHint(this, handle__minimumSizeHint); + + return *callback_return_value; + } + + friend QSize* QPdfView_virtualbase_minimumSizeHint(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__sizeHint = 0; + + // Subclass to allow providing a Go implementation + virtual QSize sizeHint() const override { + if (handle__sizeHint == 0) { + return QPdfView::sizeHint(); + } + + + QSize* callback_return_value = miqt_exec_callback_QPdfView_sizeHint(this, handle__sizeHint); + + return *callback_return_value; + } + + friend QSize* QPdfView_virtualbase_sizeHint(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setupViewport = 0; + + // Subclass to allow providing a Go implementation + virtual void setupViewport(QWidget* viewport) override { + if (handle__setupViewport == 0) { + QPdfView::setupViewport(viewport); + return; + } + + QWidget* sigval1 = viewport; + + miqt_exec_callback_QPdfView_setupViewport(this, handle__setupViewport, sigval1); + + + } + + friend void QPdfView_virtualbase_setupViewport(void* self, QWidget* viewport); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* param1, QEvent* param2) override { + if (handle__eventFilter == 0) { + return QPdfView::eventFilter(param1, param2); + } + + QObject* sigval1 = param1; + QEvent* sigval2 = param2; + + bool callback_return_value = miqt_exec_callback_QPdfView_eventFilter(this, handle__eventFilter, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfView_virtualbase_eventFilter(void* self, QObject* param1, QEvent* param2); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* param1) override { + if (handle__event == 0) { + return QPdfView::event(param1); + } + + QEvent* sigval1 = param1; + + bool callback_return_value = miqt_exec_callback_QPdfView_event(this, handle__event, sigval1); + + return callback_return_value; + } + + friend bool QPdfView_virtualbase_event(void* self, QEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__viewportEvent = 0; + + // Subclass to allow providing a Go implementation + virtual bool viewportEvent(QEvent* param1) override { + if (handle__viewportEvent == 0) { + return QPdfView::viewportEvent(param1); + } + + QEvent* sigval1 = param1; + + bool callback_return_value = miqt_exec_callback_QPdfView_viewportEvent(this, handle__viewportEvent, sigval1); + + return callback_return_value; + } + + friend bool QPdfView_virtualbase_viewportEvent(void* self, QEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mousePressEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void mousePressEvent(QMouseEvent* param1) override { + if (handle__mousePressEvent == 0) { + QPdfView::mousePressEvent(param1); + return; + } + + QMouseEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_mousePressEvent(this, handle__mousePressEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_mousePressEvent(void* self, QMouseEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mouseReleaseEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void mouseReleaseEvent(QMouseEvent* param1) override { + if (handle__mouseReleaseEvent == 0) { + QPdfView::mouseReleaseEvent(param1); + return; + } + + QMouseEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_mouseReleaseEvent(this, handle__mouseReleaseEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mouseDoubleClickEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void mouseDoubleClickEvent(QMouseEvent* param1) override { + if (handle__mouseDoubleClickEvent == 0) { + QPdfView::mouseDoubleClickEvent(param1); + return; + } + + QMouseEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_mouseDoubleClickEvent(this, handle__mouseDoubleClickEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mouseMoveEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void mouseMoveEvent(QMouseEvent* param1) override { + if (handle__mouseMoveEvent == 0) { + QPdfView::mouseMoveEvent(param1); + return; + } + + QMouseEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_mouseMoveEvent(this, handle__mouseMoveEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_mouseMoveEvent(void* self, QMouseEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__wheelEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void wheelEvent(QWheelEvent* param1) override { + if (handle__wheelEvent == 0) { + QPdfView::wheelEvent(param1); + return; + } + + QWheelEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_wheelEvent(this, handle__wheelEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_wheelEvent(void* self, QWheelEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__contextMenuEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void contextMenuEvent(QContextMenuEvent* param1) override { + if (handle__contextMenuEvent == 0) { + QPdfView::contextMenuEvent(param1); + return; + } + + QContextMenuEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_contextMenuEvent(this, handle__contextMenuEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__dragEnterEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void dragEnterEvent(QDragEnterEvent* param1) override { + if (handle__dragEnterEvent == 0) { + QPdfView::dragEnterEvent(param1); + return; + } + + QDragEnterEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_dragEnterEvent(this, handle__dragEnterEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__dragMoveEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void dragMoveEvent(QDragMoveEvent* param1) override { + if (handle__dragMoveEvent == 0) { + QPdfView::dragMoveEvent(param1); + return; + } + + QDragMoveEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_dragMoveEvent(this, handle__dragMoveEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__dragLeaveEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void dragLeaveEvent(QDragLeaveEvent* param1) override { + if (handle__dragLeaveEvent == 0) { + QPdfView::dragLeaveEvent(param1); + return; + } + + QDragLeaveEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_dragLeaveEvent(this, handle__dragLeaveEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__dropEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void dropEvent(QDropEvent* param1) override { + if (handle__dropEvent == 0) { + QPdfView::dropEvent(param1); + return; + } + + QDropEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_dropEvent(this, handle__dropEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_dropEvent(void* self, QDropEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__keyPressEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void keyPressEvent(QKeyEvent* param1) override { + if (handle__keyPressEvent == 0) { + QPdfView::keyPressEvent(param1); + return; + } + + QKeyEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_keyPressEvent(this, handle__keyPressEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_keyPressEvent(void* self, QKeyEvent* param1); + + // 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 QPdfView::viewportSizeHint(); + } + + + QSize* callback_return_value = miqt_exec_callback_QPdfView_viewportSizeHint(this, handle__viewportSizeHint); + + return *callback_return_value; + } + + friend QSize* QPdfView_virtualbase_viewportSizeHint(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__changeEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void changeEvent(QEvent* param1) override { + if (handle__changeEvent == 0) { + QPdfView::changeEvent(param1); + return; + } + + QEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_changeEvent(this, handle__changeEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_changeEvent(void* self, QEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__devType = 0; + + // Subclass to allow providing a Go implementation + virtual int devType() const override { + if (handle__devType == 0) { + return QPdfView::devType(); + } + + + int callback_return_value = miqt_exec_callback_QPdfView_devType(this, handle__devType); + + return static_cast(callback_return_value); + } + + friend int QPdfView_virtualbase_devType(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setVisible = 0; + + // Subclass to allow providing a Go implementation + virtual void setVisible(bool visible) override { + if (handle__setVisible == 0) { + QPdfView::setVisible(visible); + return; + } + + bool sigval1 = visible; + + miqt_exec_callback_QPdfView_setVisible(this, handle__setVisible, sigval1); + + + } + + friend void QPdfView_virtualbase_setVisible(void* self, bool visible); + + // cgo.Handle value for overwritten implementation + intptr_t handle__heightForWidth = 0; + + // Subclass to allow providing a Go implementation + virtual int heightForWidth(int param1) const override { + if (handle__heightForWidth == 0) { + return QPdfView::heightForWidth(param1); + } + + int sigval1 = param1; + + int callback_return_value = miqt_exec_callback_QPdfView_heightForWidth(this, handle__heightForWidth, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfView_virtualbase_heightForWidth(const void* self, int param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__hasHeightForWidth = 0; + + // Subclass to allow providing a Go implementation + virtual bool hasHeightForWidth() const override { + if (handle__hasHeightForWidth == 0) { + return QPdfView::hasHeightForWidth(); + } + + + bool callback_return_value = miqt_exec_callback_QPdfView_hasHeightForWidth(this, handle__hasHeightForWidth); + + return callback_return_value; + } + + friend bool QPdfView_virtualbase_hasHeightForWidth(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__paintEngine = 0; + + // Subclass to allow providing a Go implementation + virtual QPaintEngine* paintEngine() const override { + if (handle__paintEngine == 0) { + return QPdfView::paintEngine(); + } + + + QPaintEngine* callback_return_value = miqt_exec_callback_QPdfView_paintEngine(this, handle__paintEngine); + + return callback_return_value; + } + + friend QPaintEngine* QPdfView_virtualbase_paintEngine(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__keyReleaseEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void keyReleaseEvent(QKeyEvent* event) override { + if (handle__keyReleaseEvent == 0) { + QPdfView::keyReleaseEvent(event); + return; + } + + QKeyEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_keyReleaseEvent(this, handle__keyReleaseEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_keyReleaseEvent(void* self, QKeyEvent* 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) { + QPdfView::focusInEvent(event); + return; + } + + QFocusEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_focusInEvent(this, handle__focusInEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_focusInEvent(void* self, QFocusEvent* 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) { + QPdfView::focusOutEvent(event); + return; + } + + QFocusEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_focusOutEvent(this, handle__focusOutEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_focusOutEvent(void* self, QFocusEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__enterEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void enterEvent(QEvent* event) override { + if (handle__enterEvent == 0) { + QPdfView::enterEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_enterEvent(this, handle__enterEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_enterEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__leaveEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void leaveEvent(QEvent* event) override { + if (handle__leaveEvent == 0) { + QPdfView::leaveEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_leaveEvent(this, handle__leaveEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_leaveEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__moveEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void moveEvent(QMoveEvent* event) override { + if (handle__moveEvent == 0) { + QPdfView::moveEvent(event); + return; + } + + QMoveEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_moveEvent(this, handle__moveEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_moveEvent(void* self, QMoveEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__closeEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void closeEvent(QCloseEvent* event) override { + if (handle__closeEvent == 0) { + QPdfView::closeEvent(event); + return; + } + + QCloseEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_closeEvent(this, handle__closeEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_closeEvent(void* self, QCloseEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__tabletEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void tabletEvent(QTabletEvent* event) override { + if (handle__tabletEvent == 0) { + QPdfView::tabletEvent(event); + return; + } + + QTabletEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_tabletEvent(this, handle__tabletEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_tabletEvent(void* self, QTabletEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__actionEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void actionEvent(QActionEvent* event) override { + if (handle__actionEvent == 0) { + QPdfView::actionEvent(event); + return; + } + + QActionEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_actionEvent(this, handle__actionEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_actionEvent(void* self, QActionEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__showEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void showEvent(QShowEvent* event) override { + if (handle__showEvent == 0) { + QPdfView::showEvent(event); + return; + } + + QShowEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_showEvent(this, handle__showEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_showEvent(void* self, QShowEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__hideEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void hideEvent(QHideEvent* event) override { + if (handle__hideEvent == 0) { + QPdfView::hideEvent(event); + return; + } + + QHideEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_hideEvent(this, handle__hideEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_hideEvent(void* self, QHideEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__nativeEvent = 0; + + // Subclass to allow providing a Go implementation + virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result) override { + if (handle__nativeEvent == 0) { + return QPdfView::nativeEvent(eventType, message, result); + } + + const QByteArray eventType_qb = eventType; + struct miqt_string eventType_ms; + eventType_ms.len = eventType_qb.length(); + eventType_ms.data = static_cast(malloc(eventType_ms.len)); + memcpy(eventType_ms.data, eventType_qb.data(), eventType_ms.len); + struct miqt_string sigval1 = eventType_ms; + void* sigval2 = message; + long* sigval3 = result; + + bool callback_return_value = miqt_exec_callback_QPdfView_nativeEvent(this, handle__nativeEvent, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfView_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, long* result); + + // cgo.Handle value for overwritten implementation + intptr_t handle__metric = 0; + + // Subclass to allow providing a Go implementation + virtual int metric(QPaintDevice::PaintDeviceMetric param1) const override { + if (handle__metric == 0) { + return QPdfView::metric(param1); + } + + QPaintDevice::PaintDeviceMetric param1_ret = param1; + int sigval1 = static_cast(param1_ret); + + int callback_return_value = miqt_exec_callback_QPdfView_metric(this, handle__metric, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfView_virtualbase_metric(const void* self, int param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__initPainter = 0; + + // Subclass to allow providing a Go implementation + virtual void initPainter(QPainter* painter) const override { + if (handle__initPainter == 0) { + QPdfView::initPainter(painter); + return; + } + + QPainter* sigval1 = painter; + + miqt_exec_callback_QPdfView_initPainter(this, handle__initPainter, sigval1); + + + } + + friend void QPdfView_virtualbase_initPainter(const void* self, QPainter* painter); + + // cgo.Handle value for overwritten implementation + intptr_t handle__redirected = 0; + + // Subclass to allow providing a Go implementation + virtual QPaintDevice* redirected(QPoint* offset) const override { + if (handle__redirected == 0) { + return QPdfView::redirected(offset); + } + + QPoint* sigval1 = offset; + + QPaintDevice* callback_return_value = miqt_exec_callback_QPdfView_redirected(this, handle__redirected, sigval1); + + return callback_return_value; + } + + friend QPaintDevice* QPdfView_virtualbase_redirected(const void* self, QPoint* offset); + + // cgo.Handle value for overwritten implementation + intptr_t handle__sharedPainter = 0; + + // Subclass to allow providing a Go implementation + virtual QPainter* sharedPainter() const override { + if (handle__sharedPainter == 0) { + return QPdfView::sharedPainter(); + } + + + QPainter* callback_return_value = miqt_exec_callback_QPdfView_sharedPainter(this, handle__sharedPainter); + + return callback_return_value; + } + + friend QPainter* QPdfView_virtualbase_sharedPainter(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__inputMethodEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void inputMethodEvent(QInputMethodEvent* param1) override { + if (handle__inputMethodEvent == 0) { + QPdfView::inputMethodEvent(param1); + return; + } + + QInputMethodEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_inputMethodEvent(this, handle__inputMethodEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__inputMethodQuery = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant inputMethodQuery(Qt::InputMethodQuery param1) const override { + if (handle__inputMethodQuery == 0) { + return QPdfView::inputMethodQuery(param1); + } + + Qt::InputMethodQuery param1_ret = param1; + int sigval1 = static_cast(param1_ret); + + QVariant* callback_return_value = miqt_exec_callback_QPdfView_inputMethodQuery(this, handle__inputMethodQuery, sigval1); + + return *callback_return_value; + } + + friend QVariant* QPdfView_virtualbase_inputMethodQuery(const void* self, int param1); + + // 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 QPdfView::focusNextPrevChild(next); + } + + bool sigval1 = next; + + bool callback_return_value = miqt_exec_callback_QPdfView_focusNextPrevChild(this, handle__focusNextPrevChild, sigval1); + + return callback_return_value; + } + + friend bool QPdfView_virtualbase_focusNextPrevChild(void* self, bool next); + + // cgo.Handle value for overwritten implementation + intptr_t handle__timerEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void timerEvent(QTimerEvent* event) override { + if (handle__timerEvent == 0) { + QPdfView::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_timerEvent(this, handle__timerEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_timerEvent(void* self, QTimerEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__childEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void childEvent(QChildEvent* event) override { + if (handle__childEvent == 0) { + QPdfView::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_childEvent(this, handle__childEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_childEvent(void* self, QChildEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__customEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void customEvent(QEvent* event) override { + if (handle__customEvent == 0) { + QPdfView::customEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_customEvent(this, handle__customEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_customEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__connectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void connectNotify(const QMetaMethod& signal) override { + if (handle__connectNotify == 0) { + QPdfView::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfView_connectNotify(this, handle__connectNotify, sigval1); + + + } + + friend void QPdfView_virtualbase_connectNotify(void* self, QMetaMethod* signal); + + // cgo.Handle value for overwritten implementation + intptr_t handle__disconnectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void disconnectNotify(const QMetaMethod& signal) override { + if (handle__disconnectNotify == 0) { + QPdfView::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfView_disconnectNotify(this, handle__disconnectNotify, sigval1); + + + } + + friend void QPdfView_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend void QPdfView_protectedbase_setViewportMargins(bool* _dynamic_cast_ok, void* self, int left, int top, int right, int bottom); + friend QMargins* QPdfView_protectedbase_viewportMargins(bool* _dynamic_cast_ok, const void* self); + friend void QPdfView_protectedbase_drawFrame(bool* _dynamic_cast_ok, void* self, QPainter* param1); + friend void QPdfView_protectedbase_initStyleOption(bool* _dynamic_cast_ok, const void* self, QStyleOptionFrame* option); + friend void QPdfView_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self); + friend void QPdfView_protectedbase_create(bool* _dynamic_cast_ok, void* self); + friend void QPdfView_protectedbase_destroy(bool* _dynamic_cast_ok, void* self); + friend bool QPdfView_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self); + friend bool QPdfView_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self); + friend QObject* QPdfView_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QPdfView_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QPdfView_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QPdfView_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QPdfView* QPdfView_new(QWidget* parent) { + return new MiqtVirtualQPdfView(parent); +} + +QPdfView* QPdfView_new2() { + return new MiqtVirtualQPdfView(); +} + +void QPdfView_virtbase(QPdfView* src, QAbstractScrollArea** outptr_QAbstractScrollArea) { + *outptr_QAbstractScrollArea = static_cast(src); +} + +QMetaObject* QPdfView_metaObject(const QPdfView* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QPdfView_metacast(QPdfView* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QPdfView_tr(const char* s) { + QString _ret = QPdfView::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 QPdfView_trUtf8(const char* s) { + QString _ret = QPdfView::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 QPdfView_setDocument(QPdfView* self, QPdfDocument* document) { + self->setDocument(document); +} + +QPdfDocument* QPdfView_document(const QPdfView* self) { + return self->document(); +} + +QPdfPageNavigation* QPdfView_pageNavigation(const QPdfView* self) { + return self->pageNavigation(); +} + +int QPdfView_pageMode(const QPdfView* self) { + QPdfView::PageMode _ret = self->pageMode(); + return static_cast(_ret); +} + +int QPdfView_zoomMode(const QPdfView* self) { + QPdfView::ZoomMode _ret = self->zoomMode(); + return static_cast(_ret); +} + +double QPdfView_zoomFactor(const QPdfView* self) { + qreal _ret = self->zoomFactor(); + return static_cast(_ret); +} + +int QPdfView_pageSpacing(const QPdfView* self) { + return self->pageSpacing(); +} + +void QPdfView_setPageSpacing(QPdfView* self, int spacing) { + self->setPageSpacing(static_cast(spacing)); +} + +QMargins* QPdfView_documentMargins(const QPdfView* self) { + return new QMargins(self->documentMargins()); +} + +void QPdfView_setDocumentMargins(QPdfView* self, QMargins* margins) { + self->setDocumentMargins(*margins); +} + +void QPdfView_setPageMode(QPdfView* self, int mode) { + self->setPageMode(static_cast(mode)); +} + +void QPdfView_setZoomMode(QPdfView* self, int mode) { + self->setZoomMode(static_cast(mode)); +} + +void QPdfView_setZoomFactor(QPdfView* self, double factor) { + self->setZoomFactor(static_cast(factor)); +} + +void QPdfView_documentChanged(QPdfView* self, QPdfDocument* document) { + self->documentChanged(document); +} + +void QPdfView_connect_documentChanged(QPdfView* self, intptr_t slot) { + MiqtVirtualQPdfView::connect(self, static_cast(&QPdfView::documentChanged), self, [=](QPdfDocument* document) { + QPdfDocument* sigval1 = document; + miqt_exec_callback_QPdfView_documentChanged(slot, sigval1); + }); +} + +void QPdfView_pageModeChanged(QPdfView* self, int pageMode) { + self->pageModeChanged(static_cast(pageMode)); +} + +void QPdfView_connect_pageModeChanged(QPdfView* self, intptr_t slot) { + MiqtVirtualQPdfView::connect(self, static_cast(&QPdfView::pageModeChanged), self, [=](QPdfView::PageMode pageMode) { + QPdfView::PageMode pageMode_ret = pageMode; + int sigval1 = static_cast(pageMode_ret); + miqt_exec_callback_QPdfView_pageModeChanged(slot, sigval1); + }); +} + +void QPdfView_zoomModeChanged(QPdfView* self, int zoomMode) { + self->zoomModeChanged(static_cast(zoomMode)); +} + +void QPdfView_connect_zoomModeChanged(QPdfView* self, intptr_t slot) { + MiqtVirtualQPdfView::connect(self, static_cast(&QPdfView::zoomModeChanged), self, [=](QPdfView::ZoomMode zoomMode) { + QPdfView::ZoomMode zoomMode_ret = zoomMode; + int sigval1 = static_cast(zoomMode_ret); + miqt_exec_callback_QPdfView_zoomModeChanged(slot, sigval1); + }); +} + +void QPdfView_zoomFactorChanged(QPdfView* self, double zoomFactor) { + self->zoomFactorChanged(static_cast(zoomFactor)); +} + +void QPdfView_connect_zoomFactorChanged(QPdfView* self, intptr_t slot) { + MiqtVirtualQPdfView::connect(self, static_cast(&QPdfView::zoomFactorChanged), self, [=](qreal zoomFactor) { + qreal zoomFactor_ret = zoomFactor; + double sigval1 = static_cast(zoomFactor_ret); + miqt_exec_callback_QPdfView_zoomFactorChanged(slot, sigval1); + }); +} + +void QPdfView_pageSpacingChanged(QPdfView* self, int pageSpacing) { + self->pageSpacingChanged(static_cast(pageSpacing)); +} + +void QPdfView_connect_pageSpacingChanged(QPdfView* self, intptr_t slot) { + MiqtVirtualQPdfView::connect(self, static_cast(&QPdfView::pageSpacingChanged), self, [=](int pageSpacing) { + int sigval1 = pageSpacing; + miqt_exec_callback_QPdfView_pageSpacingChanged(slot, sigval1); + }); +} + +void QPdfView_documentMarginsChanged(QPdfView* self, QMargins* documentMargins) { + self->documentMarginsChanged(*documentMargins); +} + +void QPdfView_connect_documentMarginsChanged(QPdfView* self, intptr_t slot) { + MiqtVirtualQPdfView::connect(self, static_cast(&QPdfView::documentMarginsChanged), self, [=](QMargins documentMargins) { + QMargins* sigval1 = new QMargins(documentMargins); + miqt_exec_callback_QPdfView_documentMarginsChanged(slot, sigval1); + }); +} + +struct miqt_string QPdfView_tr2(const char* s, const char* c) { + QString _ret = QPdfView::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 QPdfView_tr3(const char* s, const char* c, int n) { + QString _ret = QPdfView::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 QPdfView_trUtf82(const char* s, const char* c) { + QString _ret = QPdfView::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 QPdfView_trUtf83(const char* s, const char* c, int n) { + QString _ret = QPdfView::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; +} + +bool QPdfView_override_virtual_paintEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__paintEvent = slot; + return true; +} + +void QPdfView_virtualbase_paintEvent(void* self, QPaintEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::paintEvent(event); + +} + +bool QPdfView_override_virtual_resizeEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__resizeEvent = slot; + return true; +} + +void QPdfView_virtualbase_resizeEvent(void* self, QResizeEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::resizeEvent(event); + +} + +bool QPdfView_override_virtual_scrollContentsBy(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__scrollContentsBy = slot; + return true; +} + +void QPdfView_virtualbase_scrollContentsBy(void* self, int dx, int dy) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::scrollContentsBy(static_cast(dx), static_cast(dy)); + +} + +bool QPdfView_override_virtual_minimumSizeHint(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__minimumSizeHint = slot; + return true; +} + +QSize* QPdfView_virtualbase_minimumSizeHint(const void* self) { + + return new QSize(( (const MiqtVirtualQPdfView*)(self) )->QPdfView::minimumSizeHint()); + +} + +bool QPdfView_override_virtual_sizeHint(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__sizeHint = slot; + return true; +} + +QSize* QPdfView_virtualbase_sizeHint(const void* self) { + + return new QSize(( (const MiqtVirtualQPdfView*)(self) )->QPdfView::sizeHint()); + +} + +bool QPdfView_override_virtual_setupViewport(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setupViewport = slot; + return true; +} + +void QPdfView_virtualbase_setupViewport(void* self, QWidget* viewport) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::setupViewport(viewport); + +} + +bool QPdfView_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QPdfView_virtualbase_eventFilter(void* self, QObject* param1, QEvent* param2) { + + return ( (MiqtVirtualQPdfView*)(self) )->QPdfView::eventFilter(param1, param2); + +} + +bool QPdfView_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QPdfView_virtualbase_event(void* self, QEvent* param1) { + + return ( (MiqtVirtualQPdfView*)(self) )->QPdfView::event(param1); + +} + +bool QPdfView_override_virtual_viewportEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__viewportEvent = slot; + return true; +} + +bool QPdfView_virtualbase_viewportEvent(void* self, QEvent* param1) { + + return ( (MiqtVirtualQPdfView*)(self) )->QPdfView::viewportEvent(param1); + +} + +bool QPdfView_override_virtual_mousePressEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mousePressEvent = slot; + return true; +} + +void QPdfView_virtualbase_mousePressEvent(void* self, QMouseEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::mousePressEvent(param1); + +} + +bool QPdfView_override_virtual_mouseReleaseEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mouseReleaseEvent = slot; + return true; +} + +void QPdfView_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::mouseReleaseEvent(param1); + +} + +bool QPdfView_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mouseDoubleClickEvent = slot; + return true; +} + +void QPdfView_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::mouseDoubleClickEvent(param1); + +} + +bool QPdfView_override_virtual_mouseMoveEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mouseMoveEvent = slot; + return true; +} + +void QPdfView_virtualbase_mouseMoveEvent(void* self, QMouseEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::mouseMoveEvent(param1); + +} + +bool QPdfView_override_virtual_wheelEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__wheelEvent = slot; + return true; +} + +void QPdfView_virtualbase_wheelEvent(void* self, QWheelEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::wheelEvent(param1); + +} + +bool QPdfView_override_virtual_contextMenuEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__contextMenuEvent = slot; + return true; +} + +void QPdfView_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::contextMenuEvent(param1); + +} + +bool QPdfView_override_virtual_dragEnterEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__dragEnterEvent = slot; + return true; +} + +void QPdfView_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::dragEnterEvent(param1); + +} + +bool QPdfView_override_virtual_dragMoveEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__dragMoveEvent = slot; + return true; +} + +void QPdfView_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::dragMoveEvent(param1); + +} + +bool QPdfView_override_virtual_dragLeaveEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__dragLeaveEvent = slot; + return true; +} + +void QPdfView_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::dragLeaveEvent(param1); + +} + +bool QPdfView_override_virtual_dropEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__dropEvent = slot; + return true; +} + +void QPdfView_virtualbase_dropEvent(void* self, QDropEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::dropEvent(param1); + +} + +bool QPdfView_override_virtual_keyPressEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__keyPressEvent = slot; + return true; +} + +void QPdfView_virtualbase_keyPressEvent(void* self, QKeyEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::keyPressEvent(param1); + +} + +bool QPdfView_override_virtual_viewportSizeHint(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__viewportSizeHint = slot; + return true; +} + +QSize* QPdfView_virtualbase_viewportSizeHint(const void* self) { + + return new QSize(( (const MiqtVirtualQPdfView*)(self) )->QPdfView::viewportSizeHint()); + +} + +bool QPdfView_override_virtual_changeEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__changeEvent = slot; + return true; +} + +void QPdfView_virtualbase_changeEvent(void* self, QEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::changeEvent(param1); + +} + +bool QPdfView_override_virtual_devType(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__devType = slot; + return true; +} + +int QPdfView_virtualbase_devType(const void* self) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::devType(); + +} + +bool QPdfView_override_virtual_setVisible(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setVisible = slot; + return true; +} + +void QPdfView_virtualbase_setVisible(void* self, bool visible) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::setVisible(visible); + +} + +bool QPdfView_override_virtual_heightForWidth(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__heightForWidth = slot; + return true; +} + +int QPdfView_virtualbase_heightForWidth(const void* self, int param1) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::heightForWidth(static_cast(param1)); + +} + +bool QPdfView_override_virtual_hasHeightForWidth(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__hasHeightForWidth = slot; + return true; +} + +bool QPdfView_virtualbase_hasHeightForWidth(const void* self) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::hasHeightForWidth(); + +} + +bool QPdfView_override_virtual_paintEngine(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__paintEngine = slot; + return true; +} + +QPaintEngine* QPdfView_virtualbase_paintEngine(const void* self) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::paintEngine(); + +} + +bool QPdfView_override_virtual_keyReleaseEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__keyReleaseEvent = slot; + return true; +} + +void QPdfView_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::keyReleaseEvent(event); + +} + +bool QPdfView_override_virtual_focusInEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__focusInEvent = slot; + return true; +} + +void QPdfView_virtualbase_focusInEvent(void* self, QFocusEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::focusInEvent(event); + +} + +bool QPdfView_override_virtual_focusOutEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__focusOutEvent = slot; + return true; +} + +void QPdfView_virtualbase_focusOutEvent(void* self, QFocusEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::focusOutEvent(event); + +} + +bool QPdfView_override_virtual_enterEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__enterEvent = slot; + return true; +} + +void QPdfView_virtualbase_enterEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::enterEvent(event); + +} + +bool QPdfView_override_virtual_leaveEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__leaveEvent = slot; + return true; +} + +void QPdfView_virtualbase_leaveEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::leaveEvent(event); + +} + +bool QPdfView_override_virtual_moveEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__moveEvent = slot; + return true; +} + +void QPdfView_virtualbase_moveEvent(void* self, QMoveEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::moveEvent(event); + +} + +bool QPdfView_override_virtual_closeEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__closeEvent = slot; + return true; +} + +void QPdfView_virtualbase_closeEvent(void* self, QCloseEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::closeEvent(event); + +} + +bool QPdfView_override_virtual_tabletEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__tabletEvent = slot; + return true; +} + +void QPdfView_virtualbase_tabletEvent(void* self, QTabletEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::tabletEvent(event); + +} + +bool QPdfView_override_virtual_actionEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__actionEvent = slot; + return true; +} + +void QPdfView_virtualbase_actionEvent(void* self, QActionEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::actionEvent(event); + +} + +bool QPdfView_override_virtual_showEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__showEvent = slot; + return true; +} + +void QPdfView_virtualbase_showEvent(void* self, QShowEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::showEvent(event); + +} + +bool QPdfView_override_virtual_hideEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__hideEvent = slot; + return true; +} + +void QPdfView_virtualbase_hideEvent(void* self, QHideEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::hideEvent(event); + +} + +bool QPdfView_override_virtual_nativeEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__nativeEvent = slot; + return true; +} + +bool QPdfView_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, long* result) { + QByteArray eventType_QByteArray(eventType.data, eventType.len); + + return ( (MiqtVirtualQPdfView*)(self) )->QPdfView::nativeEvent(eventType_QByteArray, message, static_cast(result)); + +} + +bool QPdfView_override_virtual_metric(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__metric = slot; + return true; +} + +int QPdfView_virtualbase_metric(const void* self, int param1) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::metric(static_cast(param1)); + +} + +bool QPdfView_override_virtual_initPainter(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__initPainter = slot; + return true; +} + +void QPdfView_virtualbase_initPainter(const void* self, QPainter* painter) { + + ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::initPainter(painter); + +} + +bool QPdfView_override_virtual_redirected(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__redirected = slot; + return true; +} + +QPaintDevice* QPdfView_virtualbase_redirected(const void* self, QPoint* offset) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::redirected(offset); + +} + +bool QPdfView_override_virtual_sharedPainter(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__sharedPainter = slot; + return true; +} + +QPainter* QPdfView_virtualbase_sharedPainter(const void* self) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::sharedPainter(); + +} + +bool QPdfView_override_virtual_inputMethodEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__inputMethodEvent = slot; + return true; +} + +void QPdfView_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::inputMethodEvent(param1); + +} + +bool QPdfView_override_virtual_inputMethodQuery(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__inputMethodQuery = slot; + return true; +} + +QVariant* QPdfView_virtualbase_inputMethodQuery(const void* self, int param1) { + + return new QVariant(( (const MiqtVirtualQPdfView*)(self) )->QPdfView::inputMethodQuery(static_cast(param1))); + +} + +bool QPdfView_override_virtual_focusNextPrevChild(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__focusNextPrevChild = slot; + return true; +} + +bool QPdfView_virtualbase_focusNextPrevChild(void* self, bool next) { + + return ( (MiqtVirtualQPdfView*)(self) )->QPdfView::focusNextPrevChild(next); + +} + +bool QPdfView_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QPdfView_virtualbase_timerEvent(void* self, QTimerEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::timerEvent(event); + +} + +bool QPdfView_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QPdfView_virtualbase_childEvent(void* self, QChildEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::childEvent(event); + +} + +bool QPdfView_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QPdfView_virtualbase_customEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::customEvent(event); + +} + +bool QPdfView_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QPdfView_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::connectNotify(*signal); + +} + +bool QPdfView_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QPdfView_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::disconnectNotify(*signal); + +} + +void QPdfView_protectedbase_setViewportMargins(bool* _dynamic_cast_ok, void* self, int left, int top, int right, int bottom) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->setViewportMargins(static_cast(left), static_cast(top), static_cast(right), static_cast(bottom)); + +} + +QMargins* QPdfView_protectedbase_viewportMargins(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return new QMargins(self_cast->viewportMargins()); + +} + +void QPdfView_protectedbase_drawFrame(bool* _dynamic_cast_ok, void* self, QPainter* param1) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->drawFrame(param1); + +} + +void QPdfView_protectedbase_initStyleOption(bool* _dynamic_cast_ok, const void* self, QStyleOptionFrame* option) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->initStyleOption(option); + +} + +void QPdfView_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->updateMicroFocus(); + +} + +void QPdfView_protectedbase_create(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->create(); + +} + +void QPdfView_protectedbase_destroy(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->destroy(); + +} + +bool QPdfView_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->focusNextChild(); + +} + +bool QPdfView_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->focusPreviousChild(); + +} + +QObject* QPdfView_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return self_cast->sender(); + +} + +int QPdfView_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->senderSignalIndex(); + +} + +int QPdfView_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->receivers(signal); + +} + +bool QPdfView_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->isSignalConnected(*signal); + +} + +void QPdfView_delete(QPdfView* self) { + delete self; +} + diff --git a/qt/pdf/gen_qpdfview.go b/qt/pdf/gen_qpdfview.go new file mode 100644 index 00000000..0197ed97 --- /dev/null +++ b/qt/pdf/gen_qpdfview.go @@ -0,0 +1,1877 @@ +package pdf + +/* + +#include "gen_qpdfview.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QPdfView__PageMode int + +const ( + QPdfView__SinglePage QPdfView__PageMode = 0 + QPdfView__MultiPage QPdfView__PageMode = 1 +) + +type QPdfView__ZoomMode int + +const ( + QPdfView__CustomZoom QPdfView__ZoomMode = 0 + QPdfView__FitToWidth QPdfView__ZoomMode = 1 + QPdfView__FitInView QPdfView__ZoomMode = 2 +) + +type QPdfView struct { + h *C.QPdfView + *qt.QAbstractScrollArea +} + +func (this *QPdfView) cPointer() *C.QPdfView { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfView) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfView constructs the type using only CGO pointers. +func newQPdfView(h *C.QPdfView) *QPdfView { + if h == nil { + return nil + } + var outptr_QAbstractScrollArea *C.QAbstractScrollArea = nil + C.QPdfView_virtbase(h, &outptr_QAbstractScrollArea) + + return &QPdfView{h: h, + QAbstractScrollArea: qt.UnsafeNewQAbstractScrollArea(unsafe.Pointer(outptr_QAbstractScrollArea))} +} + +// UnsafeNewQPdfView constructs the type using only unsafe pointers. +func UnsafeNewQPdfView(h unsafe.Pointer) *QPdfView { + return newQPdfView((*C.QPdfView)(h)) +} + +// NewQPdfView constructs a new QPdfView object. +func NewQPdfView(parent *qt.QWidget) *QPdfView { + + return newQPdfView(C.QPdfView_new((*C.QWidget)(parent.UnsafePointer()))) +} + +// NewQPdfView2 constructs a new QPdfView object. +func NewQPdfView2() *QPdfView { + + return newQPdfView(C.QPdfView_new2()) +} + +func (this *QPdfView) MetaObject() *qt.QMetaObject { + return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QPdfView_metaObject(this.h))) +} + +func (this *QPdfView) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QPdfView_metacast(this.h, param1_Cstring)) +} + +func QPdfView_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfView_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfView_TrUtf8(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfView_trUtf8(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfView) SetDocument(document *QPdfDocument) { + C.QPdfView_setDocument(this.h, document.cPointer()) +} + +func (this *QPdfView) Document() *QPdfDocument { + return newQPdfDocument(C.QPdfView_document(this.h)) +} + +func (this *QPdfView) PageNavigation() *QPdfPageNavigation { + return newQPdfPageNavigation(C.QPdfView_pageNavigation(this.h)) +} + +func (this *QPdfView) PageMode() QPdfView__PageMode { + return (QPdfView__PageMode)(C.QPdfView_pageMode(this.h)) +} + +func (this *QPdfView) ZoomMode() QPdfView__ZoomMode { + return (QPdfView__ZoomMode)(C.QPdfView_zoomMode(this.h)) +} + +func (this *QPdfView) ZoomFactor() float64 { + return (float64)(C.QPdfView_zoomFactor(this.h)) +} + +func (this *QPdfView) PageSpacing() int { + return (int)(C.QPdfView_pageSpacing(this.h)) +} + +func (this *QPdfView) SetPageSpacing(spacing int) { + C.QPdfView_setPageSpacing(this.h, (C.int)(spacing)) +} + +func (this *QPdfView) DocumentMargins() *qt.QMargins { + _goptr := qt.UnsafeNewQMargins(unsafe.Pointer(C.QPdfView_documentMargins(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfView) SetDocumentMargins(margins qt.QMargins) { + C.QPdfView_setDocumentMargins(this.h, (*C.QMargins)(margins.UnsafePointer())) +} + +func (this *QPdfView) SetPageMode(mode QPdfView__PageMode) { + C.QPdfView_setPageMode(this.h, (C.int)(mode)) +} + +func (this *QPdfView) SetZoomMode(mode QPdfView__ZoomMode) { + C.QPdfView_setZoomMode(this.h, (C.int)(mode)) +} + +func (this *QPdfView) SetZoomFactor(factor float64) { + C.QPdfView_setZoomFactor(this.h, (C.double)(factor)) +} + +func (this *QPdfView) DocumentChanged(document *QPdfDocument) { + C.QPdfView_documentChanged(this.h, document.cPointer()) +} +func (this *QPdfView) OnDocumentChanged(slot func(document *QPdfDocument)) { + C.QPdfView_connect_documentChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfView_documentChanged +func miqt_exec_callback_QPdfView_documentChanged(cb C.intptr_t, document *C.QPdfDocument) { + gofunc, ok := cgo.Handle(cb).Value().(func(document *QPdfDocument)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQPdfDocument(document) + + gofunc(slotval1) +} + +func (this *QPdfView) PageModeChanged(pageMode QPdfView__PageMode) { + C.QPdfView_pageModeChanged(this.h, (C.int)(pageMode)) +} +func (this *QPdfView) OnPageModeChanged(slot func(pageMode QPdfView__PageMode)) { + C.QPdfView_connect_pageModeChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfView_pageModeChanged +func miqt_exec_callback_QPdfView_pageModeChanged(cb C.intptr_t, pageMode C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(pageMode QPdfView__PageMode)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (QPdfView__PageMode)(pageMode) + + gofunc(slotval1) +} + +func (this *QPdfView) ZoomModeChanged(zoomMode QPdfView__ZoomMode) { + C.QPdfView_zoomModeChanged(this.h, (C.int)(zoomMode)) +} +func (this *QPdfView) OnZoomModeChanged(slot func(zoomMode QPdfView__ZoomMode)) { + C.QPdfView_connect_zoomModeChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfView_zoomModeChanged +func miqt_exec_callback_QPdfView_zoomModeChanged(cb C.intptr_t, zoomMode C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(zoomMode QPdfView__ZoomMode)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (QPdfView__ZoomMode)(zoomMode) + + gofunc(slotval1) +} + +func (this *QPdfView) ZoomFactorChanged(zoomFactor float64) { + C.QPdfView_zoomFactorChanged(this.h, (C.double)(zoomFactor)) +} +func (this *QPdfView) OnZoomFactorChanged(slot func(zoomFactor float64)) { + C.QPdfView_connect_zoomFactorChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfView_zoomFactorChanged +func miqt_exec_callback_QPdfView_zoomFactorChanged(cb C.intptr_t, zoomFactor C.double) { + gofunc, ok := cgo.Handle(cb).Value().(func(zoomFactor float64)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (float64)(zoomFactor) + + gofunc(slotval1) +} + +func (this *QPdfView) PageSpacingChanged(pageSpacing int) { + C.QPdfView_pageSpacingChanged(this.h, (C.int)(pageSpacing)) +} +func (this *QPdfView) OnPageSpacingChanged(slot func(pageSpacing int)) { + C.QPdfView_connect_pageSpacingChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfView_pageSpacingChanged +func miqt_exec_callback_QPdfView_pageSpacingChanged(cb C.intptr_t, pageSpacing C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(pageSpacing int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(pageSpacing) + + gofunc(slotval1) +} + +func (this *QPdfView) DocumentMarginsChanged(documentMargins qt.QMargins) { + C.QPdfView_documentMarginsChanged(this.h, (*C.QMargins)(documentMargins.UnsafePointer())) +} +func (this *QPdfView) OnDocumentMarginsChanged(slot func(documentMargins qt.QMargins)) { + C.QPdfView_connect_documentMarginsChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfView_documentMarginsChanged +func miqt_exec_callback_QPdfView_documentMarginsChanged(cb C.intptr_t, documentMargins *C.QMargins) { + gofunc, ok := cgo.Handle(cb).Value().(func(documentMargins qt.QMargins)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + documentMargins_goptr := qt.UnsafeNewQMargins(unsafe.Pointer(documentMargins)) + documentMargins_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + slotval1 := *documentMargins_goptr + + gofunc(slotval1) +} + +func QPdfView_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfView_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfView_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfView_tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfView_TrUtf82(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfView_trUtf82(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfView_TrUtf83(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfView_trUtf83(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +// SetViewportMargins can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) SetViewportMargins(left int, top int, right int, bottom int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfView_protectedbase_setViewportMargins(&_dynamic_cast_ok, unsafe.Pointer(this.h), (C.int)(left), (C.int)(top), (C.int)(right), (C.int)(bottom)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// ViewportMargins can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) ViewportMargins() qt.QMargins { + + var _dynamic_cast_ok C.bool = false + _goptr := qt.UnsafeNewQMargins(unsafe.Pointer(C.QPdfView_protectedbase_viewportMargins(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _method_ret := *_goptr + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// DrawFrame can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) DrawFrame(param1 *qt.QPainter) { + + var _dynamic_cast_ok C.bool = false + C.QPdfView_protectedbase_drawFrame(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QPainter)(param1.UnsafePointer())) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// InitStyleOption can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) InitStyleOption(option *qt.QStyleOptionFrame) { + + var _dynamic_cast_ok C.bool = false + C.QPdfView_protectedbase_initStyleOption(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QStyleOptionFrame)(option.UnsafePointer())) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// UpdateMicroFocus can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) UpdateMicroFocus() { + + var _dynamic_cast_ok C.bool = false + C.QPdfView_protectedbase_updateMicroFocus(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// Create can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) Create() { + + var _dynamic_cast_ok C.bool = false + C.QPdfView_protectedbase_create(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// Destroy can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) Destroy() { + + var _dynamic_cast_ok C.bool = false + C.QPdfView_protectedbase_destroy(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// FocusNextChild can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) FocusNextChild() bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfView_protectedbase_focusNextChild(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// FocusPreviousChild can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) FocusPreviousChild() bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfView_protectedbase_focusPreviousChild(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Sender can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) Sender() *qt.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt.UnsafeNewQObject(unsafe.Pointer(C.QPdfView_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// SenderSignalIndex can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfView_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Receivers can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) Receivers(signal string) int { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfView_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// IsSignalConnected can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) IsSignalConnected(signal *qt.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfView_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +func (this *QPdfView) callVirtualBase_PaintEvent(event *qt.QPaintEvent) { + + C.QPdfView_virtualbase_paintEvent(unsafe.Pointer(this.h), (*C.QPaintEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnPaintEvent(slot func(super func(event *qt.QPaintEvent), event *qt.QPaintEvent)) { + ok := C.QPdfView_override_virtual_paintEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_paintEvent +func miqt_exec_callback_QPdfView_paintEvent(self *C.QPdfView, cb C.intptr_t, event *C.QPaintEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QPaintEvent), event *qt.QPaintEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQPaintEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_PaintEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ResizeEvent(event *qt.QResizeEvent) { + + C.QPdfView_virtualbase_resizeEvent(unsafe.Pointer(this.h), (*C.QResizeEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnResizeEvent(slot func(super func(event *qt.QResizeEvent), event *qt.QResizeEvent)) { + ok := C.QPdfView_override_virtual_resizeEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_resizeEvent +func miqt_exec_callback_QPdfView_resizeEvent(self *C.QPdfView, cb C.intptr_t, event *C.QResizeEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QResizeEvent), event *qt.QResizeEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQResizeEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ResizeEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ScrollContentsBy(dx int, dy int) { + + C.QPdfView_virtualbase_scrollContentsBy(unsafe.Pointer(this.h), (C.int)(dx), (C.int)(dy)) + +} +func (this *QPdfView) OnScrollContentsBy(slot func(super func(dx int, dy int), dx int, dy int)) { + ok := C.QPdfView_override_virtual_scrollContentsBy(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_scrollContentsBy +func miqt_exec_callback_QPdfView_scrollContentsBy(self *C.QPdfView, cb C.intptr_t, dx C.int, dy C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(dx int, dy int), dx int, dy int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(dx) + + slotval2 := (int)(dy) + + gofunc((&QPdfView{h: self}).callVirtualBase_ScrollContentsBy, slotval1, slotval2) + +} + +func (this *QPdfView) callVirtualBase_MinimumSizeHint() *qt.QSize { + + _goptr := qt.UnsafeNewQSize(unsafe.Pointer(C.QPdfView_virtualbase_minimumSizeHint(unsafe.Pointer(this.h)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfView) OnMinimumSizeHint(slot func(super func() *qt.QSize) *qt.QSize) { + ok := C.QPdfView_override_virtual_minimumSizeHint(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_minimumSizeHint +func miqt_exec_callback_QPdfView_minimumSizeHint(self *C.QPdfView, cb C.intptr_t) *C.QSize { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *qt.QSize) *qt.QSize) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_MinimumSizeHint) + + return (*C.QSize)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_SizeHint() *qt.QSize { + + _goptr := qt.UnsafeNewQSize(unsafe.Pointer(C.QPdfView_virtualbase_sizeHint(unsafe.Pointer(this.h)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfView) OnSizeHint(slot func(super func() *qt.QSize) *qt.QSize) { + ok := C.QPdfView_override_virtual_sizeHint(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_sizeHint +func miqt_exec_callback_QPdfView_sizeHint(self *C.QPdfView, cb C.intptr_t) *C.QSize { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *qt.QSize) *qt.QSize) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_SizeHint) + + return (*C.QSize)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_SetupViewport(viewport *qt.QWidget) { + + C.QPdfView_virtualbase_setupViewport(unsafe.Pointer(this.h), (*C.QWidget)(viewport.UnsafePointer())) + +} +func (this *QPdfView) OnSetupViewport(slot func(super func(viewport *qt.QWidget), viewport *qt.QWidget)) { + ok := C.QPdfView_override_virtual_setupViewport(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_setupViewport +func miqt_exec_callback_QPdfView_setupViewport(self *C.QPdfView, cb C.intptr_t, viewport *C.QWidget) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(viewport *qt.QWidget), viewport *qt.QWidget)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQWidget(unsafe.Pointer(viewport)) + + gofunc((&QPdfView{h: self}).callVirtualBase_SetupViewport, slotval1) + +} + +func (this *QPdfView) callVirtualBase_EventFilter(param1 *qt.QObject, param2 *qt.QEvent) bool { + + return (bool)(C.QPdfView_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(param1.UnsafePointer()), (*C.QEvent)(param2.UnsafePointer()))) + +} +func (this *QPdfView) OnEventFilter(slot func(super func(param1 *qt.QObject, param2 *qt.QEvent) bool, param1 *qt.QObject, param2 *qt.QEvent) bool) { + ok := C.QPdfView_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_eventFilter +func miqt_exec_callback_QPdfView_eventFilter(self *C.QPdfView, cb C.intptr_t, param1 *C.QObject, param2 *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QObject, param2 *qt.QEvent) bool, param1 *qt.QObject, param2 *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(param1)) + + slotval2 := qt.UnsafeNewQEvent(unsafe.Pointer(param2)) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_Event(param1 *qt.QEvent) bool { + + return (bool)(C.QPdfView_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(param1.UnsafePointer()))) + +} +func (this *QPdfView) OnEvent(slot func(super func(param1 *qt.QEvent) bool, param1 *qt.QEvent) bool) { + ok := C.QPdfView_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_event +func miqt_exec_callback_QPdfView_event(self *C.QPdfView, cb C.intptr_t, param1 *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QEvent) bool, param1 *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(param1)) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_ViewportEvent(param1 *qt.QEvent) bool { + + return (bool)(C.QPdfView_virtualbase_viewportEvent(unsafe.Pointer(this.h), (*C.QEvent)(param1.UnsafePointer()))) + +} +func (this *QPdfView) OnViewportEvent(slot func(super func(param1 *qt.QEvent) bool, param1 *qt.QEvent) bool) { + ok := C.QPdfView_override_virtual_viewportEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_viewportEvent +func miqt_exec_callback_QPdfView_viewportEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QEvent) bool, param1 *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(param1)) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_ViewportEvent, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_MousePressEvent(param1 *qt.QMouseEvent) { + + C.QPdfView_virtualbase_mousePressEvent(unsafe.Pointer(this.h), (*C.QMouseEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnMousePressEvent(slot func(super func(param1 *qt.QMouseEvent), param1 *qt.QMouseEvent)) { + ok := C.QPdfView_override_virtual_mousePressEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_mousePressEvent +func miqt_exec_callback_QPdfView_mousePressEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QMouseEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QMouseEvent), param1 *qt.QMouseEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMouseEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_MousePressEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_MouseReleaseEvent(param1 *qt.QMouseEvent) { + + C.QPdfView_virtualbase_mouseReleaseEvent(unsafe.Pointer(this.h), (*C.QMouseEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnMouseReleaseEvent(slot func(super func(param1 *qt.QMouseEvent), param1 *qt.QMouseEvent)) { + ok := C.QPdfView_override_virtual_mouseReleaseEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_mouseReleaseEvent +func miqt_exec_callback_QPdfView_mouseReleaseEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QMouseEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QMouseEvent), param1 *qt.QMouseEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMouseEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_MouseReleaseEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_MouseDoubleClickEvent(param1 *qt.QMouseEvent) { + + C.QPdfView_virtualbase_mouseDoubleClickEvent(unsafe.Pointer(this.h), (*C.QMouseEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnMouseDoubleClickEvent(slot func(super func(param1 *qt.QMouseEvent), param1 *qt.QMouseEvent)) { + ok := C.QPdfView_override_virtual_mouseDoubleClickEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_mouseDoubleClickEvent +func miqt_exec_callback_QPdfView_mouseDoubleClickEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QMouseEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QMouseEvent), param1 *qt.QMouseEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMouseEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_MouseDoubleClickEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_MouseMoveEvent(param1 *qt.QMouseEvent) { + + C.QPdfView_virtualbase_mouseMoveEvent(unsafe.Pointer(this.h), (*C.QMouseEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnMouseMoveEvent(slot func(super func(param1 *qt.QMouseEvent), param1 *qt.QMouseEvent)) { + ok := C.QPdfView_override_virtual_mouseMoveEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_mouseMoveEvent +func miqt_exec_callback_QPdfView_mouseMoveEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QMouseEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QMouseEvent), param1 *qt.QMouseEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMouseEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_MouseMoveEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_WheelEvent(param1 *qt.QWheelEvent) { + + C.QPdfView_virtualbase_wheelEvent(unsafe.Pointer(this.h), (*C.QWheelEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnWheelEvent(slot func(super func(param1 *qt.QWheelEvent), param1 *qt.QWheelEvent)) { + ok := C.QPdfView_override_virtual_wheelEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_wheelEvent +func miqt_exec_callback_QPdfView_wheelEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QWheelEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QWheelEvent), param1 *qt.QWheelEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQWheelEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_WheelEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ContextMenuEvent(param1 *qt.QContextMenuEvent) { + + C.QPdfView_virtualbase_contextMenuEvent(unsafe.Pointer(this.h), (*C.QContextMenuEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnContextMenuEvent(slot func(super func(param1 *qt.QContextMenuEvent), param1 *qt.QContextMenuEvent)) { + ok := C.QPdfView_override_virtual_contextMenuEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_contextMenuEvent +func miqt_exec_callback_QPdfView_contextMenuEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QContextMenuEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QContextMenuEvent), param1 *qt.QContextMenuEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQContextMenuEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ContextMenuEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_DragEnterEvent(param1 *qt.QDragEnterEvent) { + + C.QPdfView_virtualbase_dragEnterEvent(unsafe.Pointer(this.h), (*C.QDragEnterEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnDragEnterEvent(slot func(super func(param1 *qt.QDragEnterEvent), param1 *qt.QDragEnterEvent)) { + ok := C.QPdfView_override_virtual_dragEnterEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_dragEnterEvent +func miqt_exec_callback_QPdfView_dragEnterEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QDragEnterEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QDragEnterEvent), param1 *qt.QDragEnterEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQDragEnterEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_DragEnterEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_DragMoveEvent(param1 *qt.QDragMoveEvent) { + + C.QPdfView_virtualbase_dragMoveEvent(unsafe.Pointer(this.h), (*C.QDragMoveEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnDragMoveEvent(slot func(super func(param1 *qt.QDragMoveEvent), param1 *qt.QDragMoveEvent)) { + ok := C.QPdfView_override_virtual_dragMoveEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_dragMoveEvent +func miqt_exec_callback_QPdfView_dragMoveEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QDragMoveEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QDragMoveEvent), param1 *qt.QDragMoveEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQDragMoveEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_DragMoveEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_DragLeaveEvent(param1 *qt.QDragLeaveEvent) { + + C.QPdfView_virtualbase_dragLeaveEvent(unsafe.Pointer(this.h), (*C.QDragLeaveEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnDragLeaveEvent(slot func(super func(param1 *qt.QDragLeaveEvent), param1 *qt.QDragLeaveEvent)) { + ok := C.QPdfView_override_virtual_dragLeaveEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_dragLeaveEvent +func miqt_exec_callback_QPdfView_dragLeaveEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QDragLeaveEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QDragLeaveEvent), param1 *qt.QDragLeaveEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQDragLeaveEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_DragLeaveEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_DropEvent(param1 *qt.QDropEvent) { + + C.QPdfView_virtualbase_dropEvent(unsafe.Pointer(this.h), (*C.QDropEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnDropEvent(slot func(super func(param1 *qt.QDropEvent), param1 *qt.QDropEvent)) { + ok := C.QPdfView_override_virtual_dropEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_dropEvent +func miqt_exec_callback_QPdfView_dropEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QDropEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QDropEvent), param1 *qt.QDropEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQDropEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_DropEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_KeyPressEvent(param1 *qt.QKeyEvent) { + + C.QPdfView_virtualbase_keyPressEvent(unsafe.Pointer(this.h), (*C.QKeyEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnKeyPressEvent(slot func(super func(param1 *qt.QKeyEvent), param1 *qt.QKeyEvent)) { + ok := C.QPdfView_override_virtual_keyPressEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_keyPressEvent +func miqt_exec_callback_QPdfView_keyPressEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QKeyEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QKeyEvent), param1 *qt.QKeyEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQKeyEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_KeyPressEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ViewportSizeHint() *qt.QSize { + + _goptr := qt.UnsafeNewQSize(unsafe.Pointer(C.QPdfView_virtualbase_viewportSizeHint(unsafe.Pointer(this.h)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfView) OnViewportSizeHint(slot func(super func() *qt.QSize) *qt.QSize) { + ok := C.QPdfView_override_virtual_viewportSizeHint(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_viewportSizeHint +func miqt_exec_callback_QPdfView_viewportSizeHint(self *C.QPdfView, cb C.intptr_t) *C.QSize { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *qt.QSize) *qt.QSize) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_ViewportSizeHint) + + return (*C.QSize)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_ChangeEvent(param1 *qt.QEvent) { + + C.QPdfView_virtualbase_changeEvent(unsafe.Pointer(this.h), (*C.QEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnChangeEvent(slot func(super func(param1 *qt.QEvent), param1 *qt.QEvent)) { + ok := C.QPdfView_override_virtual_changeEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_changeEvent +func miqt_exec_callback_QPdfView_changeEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QEvent), param1 *qt.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ChangeEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_DevType() int { + + return (int)(C.QPdfView_virtualbase_devType(unsafe.Pointer(this.h))) + +} +func (this *QPdfView) OnDevType(slot func(super func() int) int) { + ok := C.QPdfView_override_virtual_devType(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_devType +func miqt_exec_callback_QPdfView_devType(self *C.QPdfView, cb C.intptr_t) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_DevType) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_SetVisible(visible bool) { + + C.QPdfView_virtualbase_setVisible(unsafe.Pointer(this.h), (C.bool)(visible)) + +} +func (this *QPdfView) OnSetVisible(slot func(super func(visible bool), visible bool)) { + ok := C.QPdfView_override_virtual_setVisible(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_setVisible +func miqt_exec_callback_QPdfView_setVisible(self *C.QPdfView, cb C.intptr_t, visible C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(visible bool), visible bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(visible) + + gofunc((&QPdfView{h: self}).callVirtualBase_SetVisible, slotval1) + +} + +func (this *QPdfView) callVirtualBase_HeightForWidth(param1 int) int { + + return (int)(C.QPdfView_virtualbase_heightForWidth(unsafe.Pointer(this.h), (C.int)(param1))) + +} +func (this *QPdfView) OnHeightForWidth(slot func(super func(param1 int) int, param1 int) int) { + ok := C.QPdfView_override_virtual_heightForWidth(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_heightForWidth +func miqt_exec_callback_QPdfView_heightForWidth(self *C.QPdfView, cb C.intptr_t, param1 C.int) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 int) int, param1 int) int) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(param1) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_HeightForWidth, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_HasHeightForWidth() bool { + + return (bool)(C.QPdfView_virtualbase_hasHeightForWidth(unsafe.Pointer(this.h))) + +} +func (this *QPdfView) OnHasHeightForWidth(slot func(super func() bool) bool) { + ok := C.QPdfView_override_virtual_hasHeightForWidth(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_hasHeightForWidth +func miqt_exec_callback_QPdfView_hasHeightForWidth(self *C.QPdfView, cb C.intptr_t) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_HasHeightForWidth) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_PaintEngine() *qt.QPaintEngine { + + return qt.UnsafeNewQPaintEngine(unsafe.Pointer(C.QPdfView_virtualbase_paintEngine(unsafe.Pointer(this.h)))) + +} +func (this *QPdfView) OnPaintEngine(slot func(super func() *qt.QPaintEngine) *qt.QPaintEngine) { + ok := C.QPdfView_override_virtual_paintEngine(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_paintEngine +func miqt_exec_callback_QPdfView_paintEngine(self *C.QPdfView, cb C.intptr_t) *C.QPaintEngine { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *qt.QPaintEngine) *qt.QPaintEngine) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_PaintEngine) + + return (*C.QPaintEngine)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_KeyReleaseEvent(event *qt.QKeyEvent) { + + C.QPdfView_virtualbase_keyReleaseEvent(unsafe.Pointer(this.h), (*C.QKeyEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnKeyReleaseEvent(slot func(super func(event *qt.QKeyEvent), event *qt.QKeyEvent)) { + ok := C.QPdfView_override_virtual_keyReleaseEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_keyReleaseEvent +func miqt_exec_callback_QPdfView_keyReleaseEvent(self *C.QPdfView, cb C.intptr_t, event *C.QKeyEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QKeyEvent), event *qt.QKeyEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQKeyEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_KeyReleaseEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_FocusInEvent(event *qt.QFocusEvent) { + + C.QPdfView_virtualbase_focusInEvent(unsafe.Pointer(this.h), (*C.QFocusEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnFocusInEvent(slot func(super func(event *qt.QFocusEvent), event *qt.QFocusEvent)) { + ok := C.QPdfView_override_virtual_focusInEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_focusInEvent +func miqt_exec_callback_QPdfView_focusInEvent(self *C.QPdfView, cb C.intptr_t, event *C.QFocusEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QFocusEvent), event *qt.QFocusEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQFocusEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_FocusInEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_FocusOutEvent(event *qt.QFocusEvent) { + + C.QPdfView_virtualbase_focusOutEvent(unsafe.Pointer(this.h), (*C.QFocusEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnFocusOutEvent(slot func(super func(event *qt.QFocusEvent), event *qt.QFocusEvent)) { + ok := C.QPdfView_override_virtual_focusOutEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_focusOutEvent +func miqt_exec_callback_QPdfView_focusOutEvent(self *C.QPdfView, cb C.intptr_t, event *C.QFocusEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QFocusEvent), event *qt.QFocusEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQFocusEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_FocusOutEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_EnterEvent(event *qt.QEvent) { + + C.QPdfView_virtualbase_enterEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnEnterEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) { + ok := C.QPdfView_override_virtual_enterEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_enterEvent +func miqt_exec_callback_QPdfView_enterEvent(self *C.QPdfView, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_EnterEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_LeaveEvent(event *qt.QEvent) { + + C.QPdfView_virtualbase_leaveEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnLeaveEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) { + ok := C.QPdfView_override_virtual_leaveEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_leaveEvent +func miqt_exec_callback_QPdfView_leaveEvent(self *C.QPdfView, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_LeaveEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_MoveEvent(event *qt.QMoveEvent) { + + C.QPdfView_virtualbase_moveEvent(unsafe.Pointer(this.h), (*C.QMoveEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnMoveEvent(slot func(super func(event *qt.QMoveEvent), event *qt.QMoveEvent)) { + ok := C.QPdfView_override_virtual_moveEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_moveEvent +func miqt_exec_callback_QPdfView_moveEvent(self *C.QPdfView, cb C.intptr_t, event *C.QMoveEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QMoveEvent), event *qt.QMoveEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMoveEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_MoveEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_CloseEvent(event *qt.QCloseEvent) { + + C.QPdfView_virtualbase_closeEvent(unsafe.Pointer(this.h), (*C.QCloseEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnCloseEvent(slot func(super func(event *qt.QCloseEvent), event *qt.QCloseEvent)) { + ok := C.QPdfView_override_virtual_closeEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_closeEvent +func miqt_exec_callback_QPdfView_closeEvent(self *C.QPdfView, cb C.intptr_t, event *C.QCloseEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QCloseEvent), event *qt.QCloseEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQCloseEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_CloseEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_TabletEvent(event *qt.QTabletEvent) { + + C.QPdfView_virtualbase_tabletEvent(unsafe.Pointer(this.h), (*C.QTabletEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnTabletEvent(slot func(super func(event *qt.QTabletEvent), event *qt.QTabletEvent)) { + ok := C.QPdfView_override_virtual_tabletEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_tabletEvent +func miqt_exec_callback_QPdfView_tabletEvent(self *C.QPdfView, cb C.intptr_t, event *C.QTabletEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTabletEvent), event *qt.QTabletEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQTabletEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_TabletEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ActionEvent(event *qt.QActionEvent) { + + C.QPdfView_virtualbase_actionEvent(unsafe.Pointer(this.h), (*C.QActionEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnActionEvent(slot func(super func(event *qt.QActionEvent), event *qt.QActionEvent)) { + ok := C.QPdfView_override_virtual_actionEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_actionEvent +func miqt_exec_callback_QPdfView_actionEvent(self *C.QPdfView, cb C.intptr_t, event *C.QActionEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QActionEvent), event *qt.QActionEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQActionEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ActionEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ShowEvent(event *qt.QShowEvent) { + + C.QPdfView_virtualbase_showEvent(unsafe.Pointer(this.h), (*C.QShowEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnShowEvent(slot func(super func(event *qt.QShowEvent), event *qt.QShowEvent)) { + ok := C.QPdfView_override_virtual_showEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_showEvent +func miqt_exec_callback_QPdfView_showEvent(self *C.QPdfView, cb C.intptr_t, event *C.QShowEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QShowEvent), event *qt.QShowEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQShowEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ShowEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_HideEvent(event *qt.QHideEvent) { + + C.QPdfView_virtualbase_hideEvent(unsafe.Pointer(this.h), (*C.QHideEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnHideEvent(slot func(super func(event *qt.QHideEvent), event *qt.QHideEvent)) { + ok := C.QPdfView_override_virtual_hideEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_hideEvent +func miqt_exec_callback_QPdfView_hideEvent(self *C.QPdfView, cb C.intptr_t, event *C.QHideEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QHideEvent), event *qt.QHideEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQHideEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_HideEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_NativeEvent(eventType []byte, message unsafe.Pointer, result *int64) bool { + eventType_alias := C.struct_miqt_string{} + if len(eventType) > 0 { + eventType_alias.data = (*C.char)(unsafe.Pointer(&eventType[0])) + } else { + eventType_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + eventType_alias.len = C.size_t(len(eventType)) + + return (bool)(C.QPdfView_virtualbase_nativeEvent(unsafe.Pointer(this.h), eventType_alias, message, (*C.long)(unsafe.Pointer(result)))) + +} +func (this *QPdfView) OnNativeEvent(slot func(super func(eventType []byte, message unsafe.Pointer, result *int64) bool, eventType []byte, message unsafe.Pointer, result *int64) bool) { + ok := C.QPdfView_override_virtual_nativeEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_nativeEvent +func miqt_exec_callback_QPdfView_nativeEvent(self *C.QPdfView, cb C.intptr_t, eventType C.struct_miqt_string, message unsafe.Pointer, result *C.long) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(eventType []byte, message unsafe.Pointer, result *int64) bool, eventType []byte, message unsafe.Pointer, result *int64) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var eventType_bytearray C.struct_miqt_string = eventType + eventType_ret := C.GoBytes(unsafe.Pointer(eventType_bytearray.data), C.int(int64(eventType_bytearray.len))) + C.free(unsafe.Pointer(eventType_bytearray.data)) + slotval1 := eventType_ret + slotval2 := (unsafe.Pointer)(message) + + slotval3 := (*int64)(unsafe.Pointer(result)) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_NativeEvent, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_Metric(param1 qt.QPaintDevice__PaintDeviceMetric) int { + + return (int)(C.QPdfView_virtualbase_metric(unsafe.Pointer(this.h), (C.int)(param1))) + +} +func (this *QPdfView) OnMetric(slot func(super func(param1 qt.QPaintDevice__PaintDeviceMetric) int, param1 qt.QPaintDevice__PaintDeviceMetric) int) { + ok := C.QPdfView_override_virtual_metric(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_metric +func miqt_exec_callback_QPdfView_metric(self *C.QPdfView, cb C.intptr_t, param1 C.int) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 qt.QPaintDevice__PaintDeviceMetric) int, param1 qt.QPaintDevice__PaintDeviceMetric) int) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (qt.QPaintDevice__PaintDeviceMetric)(param1) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_Metric, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_InitPainter(painter *qt.QPainter) { + + C.QPdfView_virtualbase_initPainter(unsafe.Pointer(this.h), (*C.QPainter)(painter.UnsafePointer())) + +} +func (this *QPdfView) OnInitPainter(slot func(super func(painter *qt.QPainter), painter *qt.QPainter)) { + ok := C.QPdfView_override_virtual_initPainter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_initPainter +func miqt_exec_callback_QPdfView_initPainter(self *C.QPdfView, cb C.intptr_t, painter *C.QPainter) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(painter *qt.QPainter), painter *qt.QPainter)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQPainter(unsafe.Pointer(painter)) + + gofunc((&QPdfView{h: self}).callVirtualBase_InitPainter, slotval1) + +} + +func (this *QPdfView) callVirtualBase_Redirected(offset *qt.QPoint) *qt.QPaintDevice { + + return qt.UnsafeNewQPaintDevice(unsafe.Pointer(C.QPdfView_virtualbase_redirected(unsafe.Pointer(this.h), (*C.QPoint)(offset.UnsafePointer())))) + +} +func (this *QPdfView) OnRedirected(slot func(super func(offset *qt.QPoint) *qt.QPaintDevice, offset *qt.QPoint) *qt.QPaintDevice) { + ok := C.QPdfView_override_virtual_redirected(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_redirected +func miqt_exec_callback_QPdfView_redirected(self *C.QPdfView, cb C.intptr_t, offset *C.QPoint) *C.QPaintDevice { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(offset *qt.QPoint) *qt.QPaintDevice, offset *qt.QPoint) *qt.QPaintDevice) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQPoint(unsafe.Pointer(offset)) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_Redirected, slotval1) + + return (*C.QPaintDevice)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_SharedPainter() *qt.QPainter { + + return qt.UnsafeNewQPainter(unsafe.Pointer(C.QPdfView_virtualbase_sharedPainter(unsafe.Pointer(this.h)))) + +} +func (this *QPdfView) OnSharedPainter(slot func(super func() *qt.QPainter) *qt.QPainter) { + ok := C.QPdfView_override_virtual_sharedPainter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_sharedPainter +func miqt_exec_callback_QPdfView_sharedPainter(self *C.QPdfView, cb C.intptr_t) *C.QPainter { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *qt.QPainter) *qt.QPainter) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_SharedPainter) + + return (*C.QPainter)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_InputMethodEvent(param1 *qt.QInputMethodEvent) { + + C.QPdfView_virtualbase_inputMethodEvent(unsafe.Pointer(this.h), (*C.QInputMethodEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnInputMethodEvent(slot func(super func(param1 *qt.QInputMethodEvent), param1 *qt.QInputMethodEvent)) { + ok := C.QPdfView_override_virtual_inputMethodEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_inputMethodEvent +func miqt_exec_callback_QPdfView_inputMethodEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QInputMethodEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QInputMethodEvent), param1 *qt.QInputMethodEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQInputMethodEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_InputMethodEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_InputMethodQuery(param1 qt.InputMethodQuery) *qt.QVariant { + + _goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QPdfView_virtualbase_inputMethodQuery(unsafe.Pointer(this.h), (C.int)(param1)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfView) OnInputMethodQuery(slot func(super func(param1 qt.InputMethodQuery) *qt.QVariant, param1 qt.InputMethodQuery) *qt.QVariant) { + ok := C.QPdfView_override_virtual_inputMethodQuery(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_inputMethodQuery +func miqt_exec_callback_QPdfView_inputMethodQuery(self *C.QPdfView, cb C.intptr_t, param1 C.int) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 qt.InputMethodQuery) *qt.QVariant, param1 qt.InputMethodQuery) *qt.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (qt.InputMethodQuery)(param1) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_InputMethodQuery, slotval1) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_FocusNextPrevChild(next bool) bool { + + return (bool)(C.QPdfView_virtualbase_focusNextPrevChild(unsafe.Pointer(this.h), (C.bool)(next))) + +} +func (this *QPdfView) OnFocusNextPrevChild(slot func(super func(next bool) bool, next bool) bool) { + ok := C.QPdfView_override_virtual_focusNextPrevChild(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_focusNextPrevChild +func miqt_exec_callback_QPdfView_focusNextPrevChild(self *C.QPdfView, cb C.intptr_t, next C.bool) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(next bool) bool, next bool) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(next) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_FocusNextPrevChild, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_TimerEvent(event *qt.QTimerEvent) { + + C.QPdfView_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnTimerEvent(slot func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) { + ok := C.QPdfView_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_timerEvent +func miqt_exec_callback_QPdfView_timerEvent(self *C.QPdfView, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ChildEvent(event *qt.QChildEvent) { + + C.QPdfView_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnChildEvent(slot func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) { + ok := C.QPdfView_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_childEvent +func miqt_exec_callback_QPdfView_childEvent(self *C.QPdfView, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_CustomEvent(event *qt.QEvent) { + + C.QPdfView_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnCustomEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) { + ok := C.QPdfView_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_customEvent +func miqt_exec_callback_QPdfView_customEvent(self *C.QPdfView, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ConnectNotify(signal *qt.QMetaMethod) { + + C.QPdfView_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfView) OnConnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QPdfView_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_connectNotify +func miqt_exec_callback_QPdfView_connectNotify(self *C.QPdfView, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QPdfView) callVirtualBase_DisconnectNotify(signal *qt.QMetaMethod) { + + C.QPdfView_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfView) OnDisconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QPdfView_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_disconnectNotify +func miqt_exec_callback_QPdfView_disconnectNotify(self *C.QPdfView, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfView{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QPdfView) Delete() { + C.QPdfView_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfView) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfView) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/pdf/gen_qpdfview.h b/qt/pdf/gen_qpdfview.h new file mode 100644 index 00000000..cc2cd927 --- /dev/null +++ b/qt/pdf/gen_qpdfview.h @@ -0,0 +1,257 @@ +#pragma once +#ifndef MIQT_QT_PDF_GEN_QPDFVIEW_H +#define MIQT_QT_PDF_GEN_QPDFVIEW_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractScrollArea; +class QActionEvent; +class QChildEvent; +class QCloseEvent; +class QContextMenuEvent; +class QDragEnterEvent; +class QDragLeaveEvent; +class QDragMoveEvent; +class QDropEvent; +class QEvent; +class QFocusEvent; +class QFrame; +class QHideEvent; +class QInputMethodEvent; +class QKeyEvent; +class QMargins; +class QMetaMethod; +class QMetaObject; +class QMouseEvent; +class QMoveEvent; +class QObject; +class QPaintDevice; +class QPaintEngine; +class QPaintEvent; +class QPainter; +class QPdfDocument; +class QPdfPageNavigation; +class QPdfView; +class QPoint; +class QResizeEvent; +class QShowEvent; +class QSize; +class QStyleOptionFrame; +class QTabletEvent; +class QTimerEvent; +class QVariant; +class QWheelEvent; +class QWidget; +#else +typedef struct QAbstractScrollArea QAbstractScrollArea; +typedef struct QActionEvent QActionEvent; +typedef struct QChildEvent QChildEvent; +typedef struct QCloseEvent QCloseEvent; +typedef struct QContextMenuEvent QContextMenuEvent; +typedef struct QDragEnterEvent QDragEnterEvent; +typedef struct QDragLeaveEvent QDragLeaveEvent; +typedef struct QDragMoveEvent QDragMoveEvent; +typedef struct QDropEvent QDropEvent; +typedef struct QEvent QEvent; +typedef struct QFocusEvent QFocusEvent; +typedef struct QFrame QFrame; +typedef struct QHideEvent QHideEvent; +typedef struct QInputMethodEvent QInputMethodEvent; +typedef struct QKeyEvent QKeyEvent; +typedef struct QMargins QMargins; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QMouseEvent QMouseEvent; +typedef struct QMoveEvent QMoveEvent; +typedef struct QObject QObject; +typedef struct QPaintDevice QPaintDevice; +typedef struct QPaintEngine QPaintEngine; +typedef struct QPaintEvent QPaintEvent; +typedef struct QPainter QPainter; +typedef struct QPdfDocument QPdfDocument; +typedef struct QPdfPageNavigation QPdfPageNavigation; +typedef struct QPdfView QPdfView; +typedef struct QPoint QPoint; +typedef struct QResizeEvent QResizeEvent; +typedef struct QShowEvent QShowEvent; +typedef struct QSize QSize; +typedef struct QStyleOptionFrame QStyleOptionFrame; +typedef struct QTabletEvent QTabletEvent; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +typedef struct QWheelEvent QWheelEvent; +typedef struct QWidget QWidget; +#endif + +QPdfView* QPdfView_new(QWidget* parent); +QPdfView* QPdfView_new2(); +void QPdfView_virtbase(QPdfView* src, QAbstractScrollArea** outptr_QAbstractScrollArea); +QMetaObject* QPdfView_metaObject(const QPdfView* self); +void* QPdfView_metacast(QPdfView* self, const char* param1); +struct miqt_string QPdfView_tr(const char* s); +struct miqt_string QPdfView_trUtf8(const char* s); +void QPdfView_setDocument(QPdfView* self, QPdfDocument* document); +QPdfDocument* QPdfView_document(const QPdfView* self); +QPdfPageNavigation* QPdfView_pageNavigation(const QPdfView* self); +int QPdfView_pageMode(const QPdfView* self); +int QPdfView_zoomMode(const QPdfView* self); +double QPdfView_zoomFactor(const QPdfView* self); +int QPdfView_pageSpacing(const QPdfView* self); +void QPdfView_setPageSpacing(QPdfView* self, int spacing); +QMargins* QPdfView_documentMargins(const QPdfView* self); +void QPdfView_setDocumentMargins(QPdfView* self, QMargins* margins); +void QPdfView_setPageMode(QPdfView* self, int mode); +void QPdfView_setZoomMode(QPdfView* self, int mode); +void QPdfView_setZoomFactor(QPdfView* self, double factor); +void QPdfView_documentChanged(QPdfView* self, QPdfDocument* document); +void QPdfView_connect_documentChanged(QPdfView* self, intptr_t slot); +void QPdfView_pageModeChanged(QPdfView* self, int pageMode); +void QPdfView_connect_pageModeChanged(QPdfView* self, intptr_t slot); +void QPdfView_zoomModeChanged(QPdfView* self, int zoomMode); +void QPdfView_connect_zoomModeChanged(QPdfView* self, intptr_t slot); +void QPdfView_zoomFactorChanged(QPdfView* self, double zoomFactor); +void QPdfView_connect_zoomFactorChanged(QPdfView* self, intptr_t slot); +void QPdfView_pageSpacingChanged(QPdfView* self, int pageSpacing); +void QPdfView_connect_pageSpacingChanged(QPdfView* self, intptr_t slot); +void QPdfView_documentMarginsChanged(QPdfView* self, QMargins* documentMargins); +void QPdfView_connect_documentMarginsChanged(QPdfView* self, intptr_t slot); +void QPdfView_paintEvent(QPdfView* self, QPaintEvent* event); +void QPdfView_resizeEvent(QPdfView* self, QResizeEvent* event); +void QPdfView_scrollContentsBy(QPdfView* self, int dx, int dy); +struct miqt_string QPdfView_tr2(const char* s, const char* c); +struct miqt_string QPdfView_tr3(const char* s, const char* c, int n); +struct miqt_string QPdfView_trUtf82(const char* s, const char* c); +struct miqt_string QPdfView_trUtf83(const char* s, const char* c, int n); +bool QPdfView_override_virtual_paintEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_paintEvent(void* self, QPaintEvent* event); +bool QPdfView_override_virtual_resizeEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_resizeEvent(void* self, QResizeEvent* event); +bool QPdfView_override_virtual_scrollContentsBy(void* self, intptr_t slot); +void QPdfView_virtualbase_scrollContentsBy(void* self, int dx, int dy); +bool QPdfView_override_virtual_minimumSizeHint(void* self, intptr_t slot); +QSize* QPdfView_virtualbase_minimumSizeHint(const void* self); +bool QPdfView_override_virtual_sizeHint(void* self, intptr_t slot); +QSize* QPdfView_virtualbase_sizeHint(const void* self); +bool QPdfView_override_virtual_setupViewport(void* self, intptr_t slot); +void QPdfView_virtualbase_setupViewport(void* self, QWidget* viewport); +bool QPdfView_override_virtual_eventFilter(void* self, intptr_t slot); +bool QPdfView_virtualbase_eventFilter(void* self, QObject* param1, QEvent* param2); +bool QPdfView_override_virtual_event(void* self, intptr_t slot); +bool QPdfView_virtualbase_event(void* self, QEvent* param1); +bool QPdfView_override_virtual_viewportEvent(void* self, intptr_t slot); +bool QPdfView_virtualbase_viewportEvent(void* self, QEvent* param1); +bool QPdfView_override_virtual_mousePressEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_mousePressEvent(void* self, QMouseEvent* param1); +bool QPdfView_override_virtual_mouseReleaseEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* param1); +bool QPdfView_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* param1); +bool QPdfView_override_virtual_mouseMoveEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_mouseMoveEvent(void* self, QMouseEvent* param1); +bool QPdfView_override_virtual_wheelEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_wheelEvent(void* self, QWheelEvent* param1); +bool QPdfView_override_virtual_contextMenuEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* param1); +bool QPdfView_override_virtual_dragEnterEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* param1); +bool QPdfView_override_virtual_dragMoveEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* param1); +bool QPdfView_override_virtual_dragLeaveEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* param1); +bool QPdfView_override_virtual_dropEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_dropEvent(void* self, QDropEvent* param1); +bool QPdfView_override_virtual_keyPressEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_keyPressEvent(void* self, QKeyEvent* param1); +bool QPdfView_override_virtual_viewportSizeHint(void* self, intptr_t slot); +QSize* QPdfView_virtualbase_viewportSizeHint(const void* self); +bool QPdfView_override_virtual_changeEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_changeEvent(void* self, QEvent* param1); +bool QPdfView_override_virtual_devType(void* self, intptr_t slot); +int QPdfView_virtualbase_devType(const void* self); +bool QPdfView_override_virtual_setVisible(void* self, intptr_t slot); +void QPdfView_virtualbase_setVisible(void* self, bool visible); +bool QPdfView_override_virtual_heightForWidth(void* self, intptr_t slot); +int QPdfView_virtualbase_heightForWidth(const void* self, int param1); +bool QPdfView_override_virtual_hasHeightForWidth(void* self, intptr_t slot); +bool QPdfView_virtualbase_hasHeightForWidth(const void* self); +bool QPdfView_override_virtual_paintEngine(void* self, intptr_t slot); +QPaintEngine* QPdfView_virtualbase_paintEngine(const void* self); +bool QPdfView_override_virtual_keyReleaseEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event); +bool QPdfView_override_virtual_focusInEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_focusInEvent(void* self, QFocusEvent* event); +bool QPdfView_override_virtual_focusOutEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_focusOutEvent(void* self, QFocusEvent* event); +bool QPdfView_override_virtual_enterEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_enterEvent(void* self, QEvent* event); +bool QPdfView_override_virtual_leaveEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_leaveEvent(void* self, QEvent* event); +bool QPdfView_override_virtual_moveEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_moveEvent(void* self, QMoveEvent* event); +bool QPdfView_override_virtual_closeEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_closeEvent(void* self, QCloseEvent* event); +bool QPdfView_override_virtual_tabletEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_tabletEvent(void* self, QTabletEvent* event); +bool QPdfView_override_virtual_actionEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_actionEvent(void* self, QActionEvent* event); +bool QPdfView_override_virtual_showEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_showEvent(void* self, QShowEvent* event); +bool QPdfView_override_virtual_hideEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_hideEvent(void* self, QHideEvent* event); +bool QPdfView_override_virtual_nativeEvent(void* self, intptr_t slot); +bool QPdfView_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, long* result); +bool QPdfView_override_virtual_metric(void* self, intptr_t slot); +int QPdfView_virtualbase_metric(const void* self, int param1); +bool QPdfView_override_virtual_initPainter(void* self, intptr_t slot); +void QPdfView_virtualbase_initPainter(const void* self, QPainter* painter); +bool QPdfView_override_virtual_redirected(void* self, intptr_t slot); +QPaintDevice* QPdfView_virtualbase_redirected(const void* self, QPoint* offset); +bool QPdfView_override_virtual_sharedPainter(void* self, intptr_t slot); +QPainter* QPdfView_virtualbase_sharedPainter(const void* self); +bool QPdfView_override_virtual_inputMethodEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* param1); +bool QPdfView_override_virtual_inputMethodQuery(void* self, intptr_t slot); +QVariant* QPdfView_virtualbase_inputMethodQuery(const void* self, int param1); +bool QPdfView_override_virtual_focusNextPrevChild(void* self, intptr_t slot); +bool QPdfView_virtualbase_focusNextPrevChild(void* self, bool next); +bool QPdfView_override_virtual_timerEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QPdfView_override_virtual_childEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_childEvent(void* self, QChildEvent* event); +bool QPdfView_override_virtual_customEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_customEvent(void* self, QEvent* event); +bool QPdfView_override_virtual_connectNotify(void* self, intptr_t slot); +void QPdfView_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QPdfView_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QPdfView_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); +void QPdfView_protectedbase_setViewportMargins(bool* _dynamic_cast_ok, void* self, int left, int top, int right, int bottom); +QMargins* QPdfView_protectedbase_viewportMargins(bool* _dynamic_cast_ok, const void* self); +void QPdfView_protectedbase_drawFrame(bool* _dynamic_cast_ok, void* self, QPainter* param1); +void QPdfView_protectedbase_initStyleOption(bool* _dynamic_cast_ok, const void* self, QStyleOptionFrame* option); +void QPdfView_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self); +void QPdfView_protectedbase_create(bool* _dynamic_cast_ok, void* self); +void QPdfView_protectedbase_destroy(bool* _dynamic_cast_ok, void* self); +bool QPdfView_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self); +bool QPdfView_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self); +QObject* QPdfView_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QPdfView_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QPdfView_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QPdfView_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +void QPdfView_delete(QPdfView* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/pdf/cflags.go b/qt6/pdf/cflags.go new file mode 100644 index 00000000..c0810a5e --- /dev/null +++ b/qt6/pdf/cflags.go @@ -0,0 +1,7 @@ +package pdf + +/* +#cgo pkg-config: Qt6PdfWidgets +*/ +import "C" + diff --git a/qt6/pdf/gen_qpdfbookmarkmodel.cpp b/qt6/pdf/gen_qpdfbookmarkmodel.cpp new file mode 100644 index 00000000..01fa0c61 --- /dev/null +++ b/qt6/pdf/gen_qpdfbookmarkmodel.cpp @@ -0,0 +1,2309 @@ +#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_qpdfbookmarkmodel.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QPdfBookmarkModel_documentChanged(intptr_t, QPdfDocument*); +QVariant* miqt_exec_callback_QPdfBookmarkModel_data(const QPdfBookmarkModel*, intptr_t, QModelIndex*, int); +QModelIndex* miqt_exec_callback_QPdfBookmarkModel_index(const QPdfBookmarkModel*, intptr_t, int, int, QModelIndex*); +QModelIndex* miqt_exec_callback_QPdfBookmarkModel_parent(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +int miqt_exec_callback_QPdfBookmarkModel_rowCount(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +int miqt_exec_callback_QPdfBookmarkModel_columnCount(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +struct miqt_map /* of int to struct miqt_string */ miqt_exec_callback_QPdfBookmarkModel_roleNames(const QPdfBookmarkModel*, intptr_t); +QModelIndex* miqt_exec_callback_QPdfBookmarkModel_sibling(const QPdfBookmarkModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_hasChildren(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_setData(QPdfBookmarkModel*, intptr_t, QModelIndex*, QVariant*, int); +QVariant* miqt_exec_callback_QPdfBookmarkModel_headerData(const QPdfBookmarkModel*, intptr_t, int, int, int); +bool miqt_exec_callback_QPdfBookmarkModel_setHeaderData(QPdfBookmarkModel*, intptr_t, int, int, QVariant*, int); +struct miqt_map /* of int to QVariant* */ miqt_exec_callback_QPdfBookmarkModel_itemData(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_setItemData(QPdfBookmarkModel*, intptr_t, QModelIndex*, struct miqt_map /* of int to QVariant* */ ); +bool miqt_exec_callback_QPdfBookmarkModel_clearItemData(QPdfBookmarkModel*, intptr_t, QModelIndex*); +struct miqt_array /* of struct miqt_string */ miqt_exec_callback_QPdfBookmarkModel_mimeTypes(const QPdfBookmarkModel*, intptr_t); +QMimeData* miqt_exec_callback_QPdfBookmarkModel_mimeData(const QPdfBookmarkModel*, intptr_t, struct miqt_array /* of QModelIndex* */ ); +bool miqt_exec_callback_QPdfBookmarkModel_canDropMimeData(const QPdfBookmarkModel*, intptr_t, QMimeData*, int, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_dropMimeData(QPdfBookmarkModel*, intptr_t, QMimeData*, int, int, int, QModelIndex*); +int miqt_exec_callback_QPdfBookmarkModel_supportedDropActions(const QPdfBookmarkModel*, intptr_t); +int miqt_exec_callback_QPdfBookmarkModel_supportedDragActions(const QPdfBookmarkModel*, intptr_t); +bool miqt_exec_callback_QPdfBookmarkModel_insertRows(QPdfBookmarkModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_insertColumns(QPdfBookmarkModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_removeRows(QPdfBookmarkModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_removeColumns(QPdfBookmarkModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_moveRows(QPdfBookmarkModel*, intptr_t, QModelIndex*, int, int, QModelIndex*, int); +bool miqt_exec_callback_QPdfBookmarkModel_moveColumns(QPdfBookmarkModel*, intptr_t, QModelIndex*, int, int, QModelIndex*, int); +void miqt_exec_callback_QPdfBookmarkModel_fetchMore(QPdfBookmarkModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfBookmarkModel_canFetchMore(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +int miqt_exec_callback_QPdfBookmarkModel_flags(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +void miqt_exec_callback_QPdfBookmarkModel_sort(QPdfBookmarkModel*, intptr_t, int, int); +QModelIndex* miqt_exec_callback_QPdfBookmarkModel_buddy(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +struct miqt_array /* of QModelIndex* */ miqt_exec_callback_QPdfBookmarkModel_match(const QPdfBookmarkModel*, intptr_t, QModelIndex*, int, QVariant*, int, int); +QSize* miqt_exec_callback_QPdfBookmarkModel_span(const QPdfBookmarkModel*, intptr_t, QModelIndex*); +void miqt_exec_callback_QPdfBookmarkModel_multiData(const QPdfBookmarkModel*, intptr_t, QModelIndex*, QModelRoleDataSpan*); +bool miqt_exec_callback_QPdfBookmarkModel_submit(QPdfBookmarkModel*, intptr_t); +void miqt_exec_callback_QPdfBookmarkModel_revert(QPdfBookmarkModel*, intptr_t); +void miqt_exec_callback_QPdfBookmarkModel_resetInternalData(QPdfBookmarkModel*, intptr_t); +bool miqt_exec_callback_QPdfBookmarkModel_event(QPdfBookmarkModel*, intptr_t, QEvent*); +bool miqt_exec_callback_QPdfBookmarkModel_eventFilter(QPdfBookmarkModel*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QPdfBookmarkModel_timerEvent(QPdfBookmarkModel*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QPdfBookmarkModel_childEvent(QPdfBookmarkModel*, intptr_t, QChildEvent*); +void miqt_exec_callback_QPdfBookmarkModel_customEvent(QPdfBookmarkModel*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfBookmarkModel_connectNotify(QPdfBookmarkModel*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QPdfBookmarkModel_disconnectNotify(QPdfBookmarkModel*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQPdfBookmarkModel final : public QPdfBookmarkModel { +public: + + MiqtVirtualQPdfBookmarkModel(): QPdfBookmarkModel() {}; + MiqtVirtualQPdfBookmarkModel(QObject* parent): QPdfBookmarkModel(parent) {}; + + virtual ~MiqtVirtualQPdfBookmarkModel() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__data = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant data(const QModelIndex& index, int role) const override { + if (handle__data == 0) { + return QPdfBookmarkModel::data(index, role); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + int sigval2 = role; + + QVariant* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_data(this, handle__data, sigval1, sigval2); + + return *callback_return_value; + } + + friend QVariant* QPdfBookmarkModel_virtualbase_data(const void* self, QModelIndex* index, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__index = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex index(int row, int column, const QModelIndex& parent) const override { + if (handle__index == 0) { + return QPdfBookmarkModel::index(row, column, parent); + } + + int sigval1 = row; + int sigval2 = column; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_index(this, handle__index, sigval1, sigval2, sigval3); + + return *callback_return_value; + } + + friend QModelIndex* QPdfBookmarkModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__parent = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex parent(const QModelIndex& index) const override { + if (handle__parent == 0) { + return QPdfBookmarkModel::parent(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_parent(this, handle__parent, sigval1); + + return *callback_return_value; + } + + friend QModelIndex* QPdfBookmarkModel_virtualbase_parent(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__rowCount = 0; + + // Subclass to allow providing a Go implementation + virtual int rowCount(const QModelIndex& parent) const override { + if (handle__rowCount == 0) { + return QPdfBookmarkModel::rowCount(parent); + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + int callback_return_value = miqt_exec_callback_QPdfBookmarkModel_rowCount(this, handle__rowCount, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfBookmarkModel_virtualbase_rowCount(const void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__columnCount = 0; + + // Subclass to allow providing a Go implementation + virtual int columnCount(const QModelIndex& parent) const override { + if (handle__columnCount == 0) { + return QPdfBookmarkModel::columnCount(parent); + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + int callback_return_value = miqt_exec_callback_QPdfBookmarkModel_columnCount(this, handle__columnCount, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfBookmarkModel_virtualbase_columnCount(const void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__roleNames = 0; + + // Subclass to allow providing a Go implementation + virtual QHash roleNames() const override { + if (handle__roleNames == 0) { + return QPdfBookmarkModel::roleNames(); + } + + + struct miqt_map /* of int to struct miqt_string */ callback_return_value = miqt_exec_callback_QPdfBookmarkModel_roleNames(this, handle__roleNames); + QHash callback_return_value_QMap; + callback_return_value_QMap.reserve(callback_return_value.len); + int* callback_return_value_karr = static_cast(callback_return_value.keys); + struct miqt_string* callback_return_value_varr = static_cast(callback_return_value.values); + for(size_t i = 0; i < callback_return_value.len; ++i) { + QByteArray callback_return_value_varr_i_QByteArray(callback_return_value_varr[i].data, callback_return_value_varr[i].len); + callback_return_value_QMap[static_cast(callback_return_value_karr[i])] = callback_return_value_varr_i_QByteArray; + } + + return callback_return_value_QMap; + } + + friend struct miqt_map /* of int to struct miqt_string */ QPdfBookmarkModel_virtualbase_roleNames(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__sibling = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex sibling(int row, int column, const QModelIndex& idx) const override { + if (handle__sibling == 0) { + return QPdfBookmarkModel::sibling(row, column, idx); + } + + int sigval1 = row; + int sigval2 = column; + const QModelIndex& idx_ret = idx; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&idx_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_sibling(this, handle__sibling, sigval1, sigval2, sigval3); + + return *callback_return_value; + } + + friend QModelIndex* QPdfBookmarkModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx); + + // cgo.Handle value for overwritten implementation + intptr_t handle__hasChildren = 0; + + // Subclass to allow providing a Go implementation + virtual bool hasChildren(const QModelIndex& parent) const override { + if (handle__hasChildren == 0) { + return QPdfBookmarkModel::hasChildren(parent); + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_hasChildren(this, handle__hasChildren, sigval1); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_hasChildren(const void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setData = 0; + + // Subclass to allow providing a Go implementation + virtual bool setData(const QModelIndex& index, const QVariant& value, int role) override { + if (handle__setData == 0) { + return QPdfBookmarkModel::setData(index, value, role); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval2 = const_cast(&value_ret); + int sigval3 = role; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_setData(this, handle__setData, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__headerData = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant headerData(int section, Qt::Orientation orientation, int role) const override { + if (handle__headerData == 0) { + return QPdfBookmarkModel::headerData(section, orientation, role); + } + + int sigval1 = section; + Qt::Orientation orientation_ret = orientation; + int sigval2 = static_cast(orientation_ret); + int sigval3 = role; + + QVariant* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_headerData(this, handle__headerData, sigval1, sigval2, sigval3); + + return *callback_return_value; + } + + friend QVariant* QPdfBookmarkModel_virtualbase_headerData(const void* self, int section, int orientation, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setHeaderData = 0; + + // Subclass to allow providing a Go implementation + virtual bool setHeaderData(int section, Qt::Orientation orientation, const QVariant& value, int role) override { + if (handle__setHeaderData == 0) { + return QPdfBookmarkModel::setHeaderData(section, orientation, value, role); + } + + int sigval1 = section; + Qt::Orientation orientation_ret = orientation; + int sigval2 = static_cast(orientation_ret); + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval3 = const_cast(&value_ret); + int sigval4 = role; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_setHeaderData(this, handle__setHeaderData, sigval1, sigval2, sigval3, sigval4); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__itemData = 0; + + // Subclass to allow providing a Go implementation + virtual QMap itemData(const QModelIndex& index) const override { + if (handle__itemData == 0) { + return QPdfBookmarkModel::itemData(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + struct miqt_map /* of int to QVariant* */ callback_return_value = miqt_exec_callback_QPdfBookmarkModel_itemData(this, handle__itemData, sigval1); + QMap callback_return_value_QMap; + int* callback_return_value_karr = static_cast(callback_return_value.keys); + QVariant** callback_return_value_varr = static_cast(callback_return_value.values); + for(size_t i = 0; i < callback_return_value.len; ++i) { + callback_return_value_QMap[static_cast(callback_return_value_karr[i])] = *(callback_return_value_varr[i]); + } + + return callback_return_value_QMap; + } + + friend struct miqt_map /* of int to QVariant* */ QPdfBookmarkModel_virtualbase_itemData(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setItemData = 0; + + // Subclass to allow providing a Go implementation + virtual bool setItemData(const QModelIndex& index, const QMap& roles) override { + if (handle__setItemData == 0) { + return QPdfBookmarkModel::setItemData(index, roles); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + const QMap& roles_ret = roles; + // Convert QMap<> from C++ memory to manually-managed C memory + int* roles_karr = static_cast(malloc(sizeof(int) * roles_ret.size())); + QVariant** roles_varr = static_cast(malloc(sizeof(QVariant*) * roles_ret.size())); + int roles_ctr = 0; + for (auto roles_itr = roles_ret.keyValueBegin(); roles_itr != roles_ret.keyValueEnd(); ++roles_itr) { + roles_karr[roles_ctr] = roles_itr->first; + roles_varr[roles_ctr] = new QVariant(roles_itr->second); + roles_ctr++; + } + struct miqt_map roles_out; + roles_out.len = roles_ret.size(); + roles_out.keys = static_cast(roles_karr); + roles_out.values = static_cast(roles_varr); + struct miqt_map /* of int to QVariant* */ sigval2 = roles_out; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_setItemData(this, handle__setItemData, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */ roles); + + // cgo.Handle value for overwritten implementation + intptr_t handle__clearItemData = 0; + + // Subclass to allow providing a Go implementation + virtual bool clearItemData(const QModelIndex& index) override { + if (handle__clearItemData == 0) { + return QPdfBookmarkModel::clearItemData(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_clearItemData(this, handle__clearItemData, sigval1); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_clearItemData(void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mimeTypes = 0; + + // Subclass to allow providing a Go implementation + virtual QStringList mimeTypes() const override { + if (handle__mimeTypes == 0) { + return QPdfBookmarkModel::mimeTypes(); + } + + + struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QPdfBookmarkModel_mimeTypes(this, handle__mimeTypes); + QStringList callback_return_value_QList; + callback_return_value_QList.reserve(callback_return_value.len); + struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); + for(size_t i = 0; i < callback_return_value.len; ++i) { + QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); + callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + } + + return callback_return_value_QList; + } + + friend struct miqt_array /* of struct miqt_string */ QPdfBookmarkModel_virtualbase_mimeTypes(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mimeData = 0; + + // Subclass to allow providing a Go implementation + virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + if (handle__mimeData == 0) { + return QPdfBookmarkModel::mimeData(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; + + QMimeData* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_mimeData(this, handle__mimeData, sigval1); + + return callback_return_value; + } + + friend QMimeData* QPdfBookmarkModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes); + + // cgo.Handle value for overwritten implementation + intptr_t handle__canDropMimeData = 0; + + // Subclass to allow providing a Go implementation + virtual bool canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const override { + if (handle__canDropMimeData == 0) { + return QPdfBookmarkModel::canDropMimeData(data, action, row, column, parent); + } + + QMimeData* sigval1 = (QMimeData*) data; + Qt::DropAction action_ret = action; + int sigval2 = static_cast(action_ret); + int sigval3 = row; + int sigval4 = column; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval5 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_canDropMimeData(this, handle__canDropMimeData, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__dropMimeData = 0; + + // Subclass to allow providing a Go implementation + virtual bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override { + if (handle__dropMimeData == 0) { + return QPdfBookmarkModel::dropMimeData(data, action, row, column, parent); + } + + QMimeData* sigval1 = (QMimeData*) data; + Qt::DropAction action_ret = action; + int sigval2 = static_cast(action_ret); + int sigval3 = row; + int sigval4 = column; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval5 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_dropMimeData(this, handle__dropMimeData, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__supportedDropActions = 0; + + // Subclass to allow providing a Go implementation + virtual Qt::DropActions supportedDropActions() const override { + if (handle__supportedDropActions == 0) { + return QPdfBookmarkModel::supportedDropActions(); + } + + + int callback_return_value = miqt_exec_callback_QPdfBookmarkModel_supportedDropActions(this, handle__supportedDropActions); + + return static_cast(callback_return_value); + } + + friend int QPdfBookmarkModel_virtualbase_supportedDropActions(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__supportedDragActions = 0; + + // Subclass to allow providing a Go implementation + virtual Qt::DropActions supportedDragActions() const override { + if (handle__supportedDragActions == 0) { + return QPdfBookmarkModel::supportedDragActions(); + } + + + int callback_return_value = miqt_exec_callback_QPdfBookmarkModel_supportedDragActions(this, handle__supportedDragActions); + + return static_cast(callback_return_value); + } + + friend int QPdfBookmarkModel_virtualbase_supportedDragActions(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__insertRows = 0; + + // Subclass to allow providing a Go implementation + virtual bool insertRows(int row, int count, const QModelIndex& parent) override { + if (handle__insertRows == 0) { + return QPdfBookmarkModel::insertRows(row, count, parent); + } + + int sigval1 = row; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_insertRows(this, handle__insertRows, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__insertColumns = 0; + + // Subclass to allow providing a Go implementation + virtual bool insertColumns(int column, int count, const QModelIndex& parent) override { + if (handle__insertColumns == 0) { + return QPdfBookmarkModel::insertColumns(column, count, parent); + } + + int sigval1 = column; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_insertColumns(this, handle__insertColumns, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__removeRows = 0; + + // Subclass to allow providing a Go implementation + virtual bool removeRows(int row, int count, const QModelIndex& parent) override { + if (handle__removeRows == 0) { + return QPdfBookmarkModel::removeRows(row, count, parent); + } + + int sigval1 = row; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_removeRows(this, handle__removeRows, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__removeColumns = 0; + + // Subclass to allow providing a Go implementation + virtual bool removeColumns(int column, int count, const QModelIndex& parent) override { + if (handle__removeColumns == 0) { + return QPdfBookmarkModel::removeColumns(column, count, parent); + } + + int sigval1 = column; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_removeColumns(this, handle__removeColumns, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__moveRows = 0; + + // Subclass to allow providing a Go implementation + virtual bool moveRows(const QModelIndex& sourceParent, int sourceRow, int count, const QModelIndex& destinationParent, int destinationChild) override { + if (handle__moveRows == 0) { + return QPdfBookmarkModel::moveRows(sourceParent, sourceRow, count, destinationParent, destinationChild); + } + + const QModelIndex& sourceParent_ret = sourceParent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&sourceParent_ret); + int sigval2 = sourceRow; + int sigval3 = count; + const QModelIndex& destinationParent_ret = destinationParent; + // Cast returned reference into pointer + QModelIndex* sigval4 = const_cast(&destinationParent_ret); + int sigval5 = destinationChild; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_moveRows(this, handle__moveRows, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild); + + // cgo.Handle value for overwritten implementation + intptr_t handle__moveColumns = 0; + + // Subclass to allow providing a Go implementation + virtual bool moveColumns(const QModelIndex& sourceParent, int sourceColumn, int count, const QModelIndex& destinationParent, int destinationChild) override { + if (handle__moveColumns == 0) { + return QPdfBookmarkModel::moveColumns(sourceParent, sourceColumn, count, destinationParent, destinationChild); + } + + const QModelIndex& sourceParent_ret = sourceParent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&sourceParent_ret); + int sigval2 = sourceColumn; + int sigval3 = count; + const QModelIndex& destinationParent_ret = destinationParent; + // Cast returned reference into pointer + QModelIndex* sigval4 = const_cast(&destinationParent_ret); + int sigval5 = destinationChild; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_moveColumns(this, handle__moveColumns, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild); + + // cgo.Handle value for overwritten implementation + intptr_t handle__fetchMore = 0; + + // Subclass to allow providing a Go implementation + virtual void fetchMore(const QModelIndex& parent) override { + if (handle__fetchMore == 0) { + QPdfBookmarkModel::fetchMore(parent); + return; + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + miqt_exec_callback_QPdfBookmarkModel_fetchMore(this, handle__fetchMore, sigval1); + + + } + + friend void QPdfBookmarkModel_virtualbase_fetchMore(void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__canFetchMore = 0; + + // Subclass to allow providing a Go implementation + virtual bool canFetchMore(const QModelIndex& parent) const override { + if (handle__canFetchMore == 0) { + return QPdfBookmarkModel::canFetchMore(parent); + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_canFetchMore(this, handle__canFetchMore, sigval1); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__flags = 0; + + // Subclass to allow providing a Go implementation + virtual Qt::ItemFlags flags(const QModelIndex& index) const override { + if (handle__flags == 0) { + return QPdfBookmarkModel::flags(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + int callback_return_value = miqt_exec_callback_QPdfBookmarkModel_flags(this, handle__flags, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfBookmarkModel_virtualbase_flags(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__sort = 0; + + // Subclass to allow providing a Go implementation + virtual void sort(int column, Qt::SortOrder order) override { + if (handle__sort == 0) { + QPdfBookmarkModel::sort(column, order); + return; + } + + int sigval1 = column; + Qt::SortOrder order_ret = order; + int sigval2 = static_cast(order_ret); + + miqt_exec_callback_QPdfBookmarkModel_sort(this, handle__sort, sigval1, sigval2); + + + } + + friend void QPdfBookmarkModel_virtualbase_sort(void* self, int column, int order); + + // cgo.Handle value for overwritten implementation + intptr_t handle__buddy = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex buddy(const QModelIndex& index) const override { + if (handle__buddy == 0) { + return QPdfBookmarkModel::buddy(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_buddy(this, handle__buddy, sigval1); + + return *callback_return_value; + } + + friend QModelIndex* QPdfBookmarkModel_virtualbase_buddy(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__match = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + if (handle__match == 0) { + return QPdfBookmarkModel::match(start, role, value, hits, flags); + } + + const QModelIndex& start_ret = start; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&start_ret); + int sigval2 = role; + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval3 = const_cast(&value_ret); + int sigval4 = hits; + Qt::MatchFlags flags_ret = flags; + int sigval5 = static_cast(flags_ret); + + struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QPdfBookmarkModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); + 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; + } + + friend struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); + + // cgo.Handle value for overwritten implementation + intptr_t handle__span = 0; + + // Subclass to allow providing a Go implementation + virtual QSize span(const QModelIndex& index) const override { + if (handle__span == 0) { + return QPdfBookmarkModel::span(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + QSize* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_span(this, handle__span, sigval1); + + return *callback_return_value; + } + + friend QSize* QPdfBookmarkModel_virtualbase_span(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__multiData = 0; + + // Subclass to allow providing a Go implementation + virtual void multiData(const QModelIndex& index, QModelRoleDataSpan roleDataSpan) const override { + if (handle__multiData == 0) { + QPdfBookmarkModel::multiData(index, roleDataSpan); + return; + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + QModelRoleDataSpan* sigval2 = new QModelRoleDataSpan(roleDataSpan); + + miqt_exec_callback_QPdfBookmarkModel_multiData(this, handle__multiData, sigval1, sigval2); + + + } + + friend void QPdfBookmarkModel_virtualbase_multiData(const void* self, QModelIndex* index, QModelRoleDataSpan* roleDataSpan); + + // cgo.Handle value for overwritten implementation + intptr_t handle__submit = 0; + + // Subclass to allow providing a Go implementation + virtual bool submit() override { + if (handle__submit == 0) { + return QPdfBookmarkModel::submit(); + } + + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_submit(this, handle__submit); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_submit(void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__revert = 0; + + // Subclass to allow providing a Go implementation + virtual void revert() override { + if (handle__revert == 0) { + QPdfBookmarkModel::revert(); + return; + } + + + miqt_exec_callback_QPdfBookmarkModel_revert(this, handle__revert); + + + } + + friend void QPdfBookmarkModel_virtualbase_revert(void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__resetInternalData = 0; + + // Subclass to allow providing a Go implementation + virtual void resetInternalData() override { + if (handle__resetInternalData == 0) { + QPdfBookmarkModel::resetInternalData(); + return; + } + + + miqt_exec_callback_QPdfBookmarkModel_resetInternalData(this, handle__resetInternalData); + + + } + + friend void QPdfBookmarkModel_virtualbase_resetInternalData(void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QPdfBookmarkModel::event(event); + } + + QEvent* sigval1 = event; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_event(this, handle__event, sigval1); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QPdfBookmarkModel::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + + bool callback_return_value = miqt_exec_callback_QPdfBookmarkModel_eventFilter(this, handle__eventFilter, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfBookmarkModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__timerEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void timerEvent(QTimerEvent* event) override { + if (handle__timerEvent == 0) { + QPdfBookmarkModel::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + + miqt_exec_callback_QPdfBookmarkModel_timerEvent(this, handle__timerEvent, sigval1); + + + } + + friend void QPdfBookmarkModel_virtualbase_timerEvent(void* self, QTimerEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__childEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void childEvent(QChildEvent* event) override { + if (handle__childEvent == 0) { + QPdfBookmarkModel::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + + miqt_exec_callback_QPdfBookmarkModel_childEvent(this, handle__childEvent, sigval1); + + + } + + friend void QPdfBookmarkModel_virtualbase_childEvent(void* self, QChildEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__customEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void customEvent(QEvent* event) override { + if (handle__customEvent == 0) { + QPdfBookmarkModel::customEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfBookmarkModel_customEvent(this, handle__customEvent, sigval1); + + + } + + friend void QPdfBookmarkModel_virtualbase_customEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__connectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void connectNotify(const QMetaMethod& signal) override { + if (handle__connectNotify == 0) { + QPdfBookmarkModel::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfBookmarkModel_connectNotify(this, handle__connectNotify, sigval1); + + + } + + friend void QPdfBookmarkModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); + + // cgo.Handle value for overwritten implementation + intptr_t handle__disconnectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void disconnectNotify(const QMetaMethod& signal) override { + if (handle__disconnectNotify == 0) { + QPdfBookmarkModel::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfBookmarkModel_disconnectNotify(this, handle__disconnectNotify, sigval1); + + + } + + friend void QPdfBookmarkModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QModelIndex* QPdfBookmarkModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column); + friend void QPdfBookmarkModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */ indexes, QDataStream* stream); + friend bool QPdfBookmarkModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream); + friend void QPdfBookmarkModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfBookmarkModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self); + friend void QPdfBookmarkModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfBookmarkModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self); + friend bool QPdfBookmarkModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow); + friend void QPdfBookmarkModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self); + friend void QPdfBookmarkModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfBookmarkModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self); + friend void QPdfBookmarkModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfBookmarkModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self); + friend bool QPdfBookmarkModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn); + friend void QPdfBookmarkModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self); + friend void QPdfBookmarkModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self); + friend void QPdfBookmarkModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self); + friend void QPdfBookmarkModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to); + friend void QPdfBookmarkModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */ from, struct miqt_array /* of QModelIndex* */ to); + friend struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self); + friend QObject* QPdfBookmarkModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QPdfBookmarkModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QPdfBookmarkModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QPdfBookmarkModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QPdfBookmarkModel* QPdfBookmarkModel_new() { + return new MiqtVirtualQPdfBookmarkModel(); +} + +QPdfBookmarkModel* QPdfBookmarkModel_new2(QObject* parent) { + return new MiqtVirtualQPdfBookmarkModel(parent); +} + +void QPdfBookmarkModel_virtbase(QPdfBookmarkModel* src, QAbstractItemModel** outptr_QAbstractItemModel) { + *outptr_QAbstractItemModel = static_cast(src); +} + +QMetaObject* QPdfBookmarkModel_metaObject(const QPdfBookmarkModel* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QPdfBookmarkModel_metacast(QPdfBookmarkModel* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QPdfBookmarkModel_tr(const char* s) { + QString _ret = QPdfBookmarkModel::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; +} + +QPdfDocument* QPdfBookmarkModel_document(const QPdfBookmarkModel* self) { + return self->document(); +} + +void QPdfBookmarkModel_setDocument(QPdfBookmarkModel* self, QPdfDocument* document) { + self->setDocument(document); +} + +QVariant* QPdfBookmarkModel_data(const QPdfBookmarkModel* self, QModelIndex* index, int role) { + return new QVariant(self->data(*index, static_cast(role))); +} + +QModelIndex* QPdfBookmarkModel_index(const QPdfBookmarkModel* self, int row, int column, QModelIndex* parent) { + return new QModelIndex(self->index(static_cast(row), static_cast(column), *parent)); +} + +QModelIndex* QPdfBookmarkModel_parent(const QPdfBookmarkModel* self, QModelIndex* index) { + return new QModelIndex(self->parent(*index)); +} + +int QPdfBookmarkModel_rowCount(const QPdfBookmarkModel* self, QModelIndex* parent) { + return self->rowCount(*parent); +} + +int QPdfBookmarkModel_columnCount(const QPdfBookmarkModel* self, QModelIndex* parent) { + return self->columnCount(*parent); +} + +struct miqt_map /* of int to struct miqt_string */ QPdfBookmarkModel_roleNames(const QPdfBookmarkModel* self) { + QHash _ret = self->roleNames(); + // Convert QMap<> from C++ memory to manually-managed C memory + int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); + struct miqt_string* _varr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + _karr[_ctr] = _itr->first; + QByteArray _hashval_qb = _itr->second; + struct miqt_string _hashval_ms; + _hashval_ms.len = _hashval_qb.length(); + _hashval_ms.data = static_cast(malloc(_hashval_ms.len)); + memcpy(_hashval_ms.data, _hashval_qb.data(), _hashval_ms.len); + _varr[_ctr] = _hashval_ms; + _ctr++; + } + struct miqt_map _out; + _out.len = _ret.size(); + _out.keys = static_cast(_karr); + _out.values = static_cast(_varr); + return _out; +} + +void QPdfBookmarkModel_documentChanged(QPdfBookmarkModel* self, QPdfDocument* document) { + self->documentChanged(document); +} + +void QPdfBookmarkModel_connect_documentChanged(QPdfBookmarkModel* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel::connect(self, static_cast(&QPdfBookmarkModel::documentChanged), self, [=](QPdfDocument* document) { + QPdfDocument* sigval1 = document; + miqt_exec_callback_QPdfBookmarkModel_documentChanged(slot, sigval1); + }); +} + +struct miqt_string QPdfBookmarkModel_tr2(const char* s, const char* c) { + QString _ret = QPdfBookmarkModel::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 QPdfBookmarkModel_tr3(const char* s, const char* c, int n) { + QString _ret = QPdfBookmarkModel::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; +} + +bool QPdfBookmarkModel_override_virtual_data(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__data = slot; + return true; +} + +QVariant* QPdfBookmarkModel_virtualbase_data(const void* self, QModelIndex* index, int role) { + + return new QVariant(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::data(*index, static_cast(role))); + +} + +bool QPdfBookmarkModel_override_virtual_index(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__index = slot; + return true; +} + +QModelIndex* QPdfBookmarkModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent) { + + return new QModelIndex(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::index(static_cast(row), static_cast(column), *parent)); + +} + +bool QPdfBookmarkModel_override_virtual_parent(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__parent = slot; + return true; +} + +QModelIndex* QPdfBookmarkModel_virtualbase_parent(const void* self, QModelIndex* index) { + + return new QModelIndex(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::parent(*index)); + +} + +bool QPdfBookmarkModel_override_virtual_rowCount(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__rowCount = slot; + return true; +} + +int QPdfBookmarkModel_virtualbase_rowCount(const void* self, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::rowCount(*parent); + +} + +bool QPdfBookmarkModel_override_virtual_columnCount(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__columnCount = slot; + return true; +} + +int QPdfBookmarkModel_virtualbase_columnCount(const void* self, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::columnCount(*parent); + +} + +bool QPdfBookmarkModel_override_virtual_roleNames(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__roleNames = slot; + return true; +} + +struct miqt_map /* of int to struct miqt_string */ QPdfBookmarkModel_virtualbase_roleNames(const void* self) { + + QHash _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::roleNames(); + // Convert QMap<> from C++ memory to manually-managed C memory + int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); + struct miqt_string* _varr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + _karr[_ctr] = _itr->first; + QByteArray _hashval_qb = _itr->second; + struct miqt_string _hashval_ms; + _hashval_ms.len = _hashval_qb.length(); + _hashval_ms.data = static_cast(malloc(_hashval_ms.len)); + memcpy(_hashval_ms.data, _hashval_qb.data(), _hashval_ms.len); + _varr[_ctr] = _hashval_ms; + _ctr++; + } + struct miqt_map _out; + _out.len = _ret.size(); + _out.keys = static_cast(_karr); + _out.values = static_cast(_varr); + return _out; + +} + +bool QPdfBookmarkModel_override_virtual_sibling(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__sibling = slot; + return true; +} + +QModelIndex* QPdfBookmarkModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx) { + + return new QModelIndex(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::sibling(static_cast(row), static_cast(column), *idx)); + +} + +bool QPdfBookmarkModel_override_virtual_hasChildren(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__hasChildren = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_hasChildren(const void* self, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::hasChildren(*parent); + +} + +bool QPdfBookmarkModel_override_virtual_setData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setData = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::setData(*index, *value, static_cast(role)); + +} + +bool QPdfBookmarkModel_override_virtual_headerData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__headerData = slot; + return true; +} + +QVariant* QPdfBookmarkModel_virtualbase_headerData(const void* self, int section, int orientation, int role) { + + return new QVariant(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::headerData(static_cast(section), static_cast(orientation), static_cast(role))); + +} + +bool QPdfBookmarkModel_override_virtual_setHeaderData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setHeaderData = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::setHeaderData(static_cast(section), static_cast(orientation), *value, static_cast(role)); + +} + +bool QPdfBookmarkModel_override_virtual_itemData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__itemData = slot; + return true; +} + +struct miqt_map /* of int to QVariant* */ QPdfBookmarkModel_virtualbase_itemData(const void* self, QModelIndex* index) { + + QMap _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::itemData(*index); + // Convert QMap<> from C++ memory to manually-managed C memory + int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); + QVariant** _varr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + _karr[_ctr] = _itr->first; + _varr[_ctr] = new QVariant(_itr->second); + _ctr++; + } + struct miqt_map _out; + _out.len = _ret.size(); + _out.keys = static_cast(_karr); + _out.values = static_cast(_varr); + return _out; + +} + +bool QPdfBookmarkModel_override_virtual_setItemData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setItemData = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */ roles) { + QMap roles_QMap; + int* roles_karr = static_cast(roles.keys); + QVariant** roles_varr = static_cast(roles.values); + for(size_t i = 0; i < roles.len; ++i) { + roles_QMap[static_cast(roles_karr[i])] = *(roles_varr[i]); + } + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::setItemData(*index, roles_QMap); + +} + +bool QPdfBookmarkModel_override_virtual_clearItemData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__clearItemData = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_clearItemData(void* self, QModelIndex* index) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::clearItemData(*index); + +} + +bool QPdfBookmarkModel_override_virtual_mimeTypes(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mimeTypes = slot; + return true; +} + +struct miqt_array /* of struct miqt_string */ QPdfBookmarkModel_virtualbase_mimeTypes(const void* self) { + + QStringList _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::mimeTypes(); + // Convert QList<> from C++ memory to manually-managed C memory + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QString _lv_ret = _ret[i]; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _lv_b = _lv_ret.toUtf8(); + struct miqt_string _lv_ms; + _lv_ms.len = _lv_b.length(); + _lv_ms.data = static_cast(malloc(_lv_ms.len)); + memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len); + _arr[i] = _lv_ms; + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; + +} + +bool QPdfBookmarkModel_override_virtual_mimeData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mimeData = slot; + return true; +} + +QMimeData* QPdfBookmarkModel_virtualbase_mimeData(const void* 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])); + } + + return ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::mimeData(indexes_QList); + +} + +bool QPdfBookmarkModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__canDropMimeData = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::canDropMimeData(data, static_cast(action), static_cast(row), static_cast(column), *parent); + +} + +bool QPdfBookmarkModel_override_virtual_dropMimeData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__dropMimeData = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::dropMimeData(data, static_cast(action), static_cast(row), static_cast(column), *parent); + +} + +bool QPdfBookmarkModel_override_virtual_supportedDropActions(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__supportedDropActions = slot; + return true; +} + +int QPdfBookmarkModel_virtualbase_supportedDropActions(const void* self) { + + Qt::DropActions _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::supportedDropActions(); + return static_cast(_ret); + +} + +bool QPdfBookmarkModel_override_virtual_supportedDragActions(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__supportedDragActions = slot; + return true; +} + +int QPdfBookmarkModel_virtualbase_supportedDragActions(const void* self) { + + Qt::DropActions _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::supportedDragActions(); + return static_cast(_ret); + +} + +bool QPdfBookmarkModel_override_virtual_insertRows(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__insertRows = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::insertRows(static_cast(row), static_cast(count), *parent); + +} + +bool QPdfBookmarkModel_override_virtual_insertColumns(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__insertColumns = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::insertColumns(static_cast(column), static_cast(count), *parent); + +} + +bool QPdfBookmarkModel_override_virtual_removeRows(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__removeRows = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::removeRows(static_cast(row), static_cast(count), *parent); + +} + +bool QPdfBookmarkModel_override_virtual_removeColumns(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__removeColumns = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::removeColumns(static_cast(column), static_cast(count), *parent); + +} + +bool QPdfBookmarkModel_override_virtual_moveRows(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__moveRows = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::moveRows(*sourceParent, static_cast(sourceRow), static_cast(count), *destinationParent, static_cast(destinationChild)); + +} + +bool QPdfBookmarkModel_override_virtual_moveColumns(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__moveColumns = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::moveColumns(*sourceParent, static_cast(sourceColumn), static_cast(count), *destinationParent, static_cast(destinationChild)); + +} + +bool QPdfBookmarkModel_override_virtual_fetchMore(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__fetchMore = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_fetchMore(void* self, QModelIndex* parent) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::fetchMore(*parent); + +} + +bool QPdfBookmarkModel_override_virtual_canFetchMore(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__canFetchMore = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::canFetchMore(*parent); + +} + +bool QPdfBookmarkModel_override_virtual_flags(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__flags = slot; + return true; +} + +int QPdfBookmarkModel_virtualbase_flags(const void* self, QModelIndex* index) { + + Qt::ItemFlags _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::flags(*index); + return static_cast(_ret); + +} + +bool QPdfBookmarkModel_override_virtual_sort(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__sort = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_sort(void* self, int column, int order) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::sort(static_cast(column), static_cast(order)); + +} + +bool QPdfBookmarkModel_override_virtual_buddy(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__buddy = slot; + return true; +} + +QModelIndex* QPdfBookmarkModel_virtualbase_buddy(const void* self, QModelIndex* index) { + + return new QModelIndex(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::buddy(*index)); + +} + +bool QPdfBookmarkModel_override_virtual_match(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__match = slot; + return true; +} + +struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { + + QModelIndexList _ret = ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + // 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; + +} + +bool QPdfBookmarkModel_override_virtual_span(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__span = slot; + return true; +} + +QSize* QPdfBookmarkModel_virtualbase_span(const void* self, QModelIndex* index) { + + return new QSize(( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::span(*index)); + +} + +bool QPdfBookmarkModel_override_virtual_multiData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__multiData = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_multiData(const void* self, QModelIndex* index, QModelRoleDataSpan* roleDataSpan) { + + ( (const MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::multiData(*index, *roleDataSpan); + +} + +bool QPdfBookmarkModel_override_virtual_submit(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__submit = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_submit(void* self) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::submit(); + +} + +bool QPdfBookmarkModel_override_virtual_revert(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__revert = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_revert(void* self) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::revert(); + +} + +bool QPdfBookmarkModel_override_virtual_resetInternalData(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__resetInternalData = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_resetInternalData(void* self) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::resetInternalData(); + +} + +bool QPdfBookmarkModel_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_event(void* self, QEvent* event) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::event(event); + +} + +bool QPdfBookmarkModel_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QPdfBookmarkModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + + return ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::eventFilter(watched, event); + +} + +bool QPdfBookmarkModel_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_timerEvent(void* self, QTimerEvent* event) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::timerEvent(event); + +} + +bool QPdfBookmarkModel_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_childEvent(void* self, QChildEvent* event) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::childEvent(event); + +} + +bool QPdfBookmarkModel_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_customEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::customEvent(event); + +} + +bool QPdfBookmarkModel_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::connectNotify(*signal); + +} + +bool QPdfBookmarkModel_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QPdfBookmarkModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfBookmarkModel*)(self) )->QPdfBookmarkModel::disconnectNotify(*signal); + +} + +QModelIndex* QPdfBookmarkModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return new QModelIndex(self_cast->createIndex(static_cast(row), static_cast(column))); + +} + +void QPdfBookmarkModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */ indexes, QDataStream* stream) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + 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_cast->encodeData(indexes_QList, *stream); + +} + +bool QPdfBookmarkModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->decodeData(static_cast(row), static_cast(column), *parent, *stream); + +} + +void QPdfBookmarkModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginInsertRows(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfBookmarkModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endInsertRows(); + +} + +void QPdfBookmarkModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginRemoveRows(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfBookmarkModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endRemoveRows(); + +} + +bool QPdfBookmarkModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->beginMoveRows(*sourceParent, static_cast(sourceFirst), static_cast(sourceLast), *destinationParent, static_cast(destinationRow)); + +} + +void QPdfBookmarkModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endMoveRows(); + +} + +void QPdfBookmarkModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginInsertColumns(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfBookmarkModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endInsertColumns(); + +} + +void QPdfBookmarkModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginRemoveColumns(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfBookmarkModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endRemoveColumns(); + +} + +bool QPdfBookmarkModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->beginMoveColumns(*sourceParent, static_cast(sourceFirst), static_cast(sourceLast), *destinationParent, static_cast(destinationColumn)); + +} + +void QPdfBookmarkModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endMoveColumns(); + +} + +void QPdfBookmarkModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginResetModel(); + +} + +void QPdfBookmarkModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endResetModel(); + +} + +void QPdfBookmarkModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->changePersistentIndex(*from, *to); + +} + +void QPdfBookmarkModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */ from, struct miqt_array /* of QModelIndex* */ to) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + QModelIndexList from_QList; + from_QList.reserve(from.len); + QModelIndex** from_arr = static_cast(from.data); + for(size_t i = 0; i < from.len; ++i) { + from_QList.push_back(*(from_arr[i])); + } + QModelIndexList to_QList; + to_QList.reserve(to.len); + QModelIndex** to_arr = static_cast(to.data); + for(size_t i = 0; i < to.len; ++i) { + to_QList.push_back(*(to_arr[i])); + } + + self_cast->changePersistentIndexList(from_QList, to_QList); + +} + +struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return (struct miqt_array){}; + } + + *_dynamic_cast_ok = true; + + QModelIndexList _ret = self_cast->persistentIndexList(); + // 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; + +} + +QObject* QPdfBookmarkModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return self_cast->sender(); + +} + +int QPdfBookmarkModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->senderSignalIndex(); + +} + +int QPdfBookmarkModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->receivers(signal); + +} + +bool QPdfBookmarkModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQPdfBookmarkModel* self_cast = dynamic_cast( (QPdfBookmarkModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->isSignalConnected(*signal); + +} + +void QPdfBookmarkModel_delete(QPdfBookmarkModel* self) { + delete self; +} + diff --git a/qt6/pdf/gen_qpdfbookmarkmodel.go b/qt6/pdf/gen_qpdfbookmarkmodel.go new file mode 100644 index 00000000..6c574071 --- /dev/null +++ b/qt6/pdf/gen_qpdfbookmarkmodel.go @@ -0,0 +1,1970 @@ +package pdf + +/* + +#include "gen_qpdfbookmarkmodel.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QPdfBookmarkModel__Role int + +const ( + QPdfBookmarkModel__Title QPdfBookmarkModel__Role = 256 + QPdfBookmarkModel__Level QPdfBookmarkModel__Role = 257 + QPdfBookmarkModel__Page QPdfBookmarkModel__Role = 258 + QPdfBookmarkModel__Location QPdfBookmarkModel__Role = 259 + QPdfBookmarkModel__Zoom QPdfBookmarkModel__Role = 260 + QPdfBookmarkModel__NRoles QPdfBookmarkModel__Role = 261 +) + +type QPdfBookmarkModel struct { + h *C.QPdfBookmarkModel + *qt6.QAbstractItemModel +} + +func (this *QPdfBookmarkModel) cPointer() *C.QPdfBookmarkModel { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfBookmarkModel) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfBookmarkModel constructs the type using only CGO pointers. +func newQPdfBookmarkModel(h *C.QPdfBookmarkModel) *QPdfBookmarkModel { + if h == nil { + return nil + } + var outptr_QAbstractItemModel *C.QAbstractItemModel = nil + C.QPdfBookmarkModel_virtbase(h, &outptr_QAbstractItemModel) + + return &QPdfBookmarkModel{h: h, + QAbstractItemModel: qt6.UnsafeNewQAbstractItemModel(unsafe.Pointer(outptr_QAbstractItemModel))} +} + +// UnsafeNewQPdfBookmarkModel constructs the type using only unsafe pointers. +func UnsafeNewQPdfBookmarkModel(h unsafe.Pointer) *QPdfBookmarkModel { + return newQPdfBookmarkModel((*C.QPdfBookmarkModel)(h)) +} + +// NewQPdfBookmarkModel constructs a new QPdfBookmarkModel object. +func NewQPdfBookmarkModel() *QPdfBookmarkModel { + + return newQPdfBookmarkModel(C.QPdfBookmarkModel_new()) +} + +// NewQPdfBookmarkModel2 constructs a new QPdfBookmarkModel object. +func NewQPdfBookmarkModel2(parent *qt6.QObject) *QPdfBookmarkModel { + + return newQPdfBookmarkModel(C.QPdfBookmarkModel_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QPdfBookmarkModel) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QPdfBookmarkModel_metaObject(this.h))) +} + +func (this *QPdfBookmarkModel) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QPdfBookmarkModel_metacast(this.h, param1_Cstring)) +} + +func QPdfBookmarkModel_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfBookmarkModel_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfBookmarkModel) Document() *QPdfDocument { + return newQPdfDocument(C.QPdfBookmarkModel_document(this.h)) +} + +func (this *QPdfBookmarkModel) SetDocument(document *QPdfDocument) { + C.QPdfBookmarkModel_setDocument(this.h, document.cPointer()) +} + +func (this *QPdfBookmarkModel) Data(index *qt6.QModelIndex, role int) *qt6.QVariant { + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QPdfBookmarkModel_data(this.h, (*C.QModelIndex)(index.UnsafePointer()), (C.int)(role)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfBookmarkModel) Index(row int, column int, parent *qt6.QModelIndex) *qt6.QModelIndex { + _goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_index(this.h, (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfBookmarkModel) Parent(index *qt6.QModelIndex) *qt6.QModelIndex { + _goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_parent(this.h, (*C.QModelIndex)(index.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfBookmarkModel) RowCount(parent *qt6.QModelIndex) int { + return (int)(C.QPdfBookmarkModel_rowCount(this.h, (*C.QModelIndex)(parent.UnsafePointer()))) +} + +func (this *QPdfBookmarkModel) ColumnCount(parent *qt6.QModelIndex) int { + return (int)(C.QPdfBookmarkModel_columnCount(this.h, (*C.QModelIndex)(parent.UnsafePointer()))) +} + +func (this *QPdfBookmarkModel) RoleNames() map[int][]byte { + var _mm C.struct_miqt_map = C.QPdfBookmarkModel_roleNames(this.h) + _ret := make(map[int][]byte, int(_mm.len)) + _Keys := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + _entry_Key := (int)(_Keys[i]) + + var _hashval_bytearray C.struct_miqt_string = _Values[i] + _hashval_ret := C.GoBytes(unsafe.Pointer(_hashval_bytearray.data), C.int(int64(_hashval_bytearray.len))) + C.free(unsafe.Pointer(_hashval_bytearray.data)) + _entry_Value := _hashval_ret + _ret[_entry_Key] = _entry_Value + } + return _ret +} + +func (this *QPdfBookmarkModel) DocumentChanged(document *QPdfDocument) { + C.QPdfBookmarkModel_documentChanged(this.h, document.cPointer()) +} +func (this *QPdfBookmarkModel) OnDocumentChanged(slot func(document *QPdfDocument)) { + C.QPdfBookmarkModel_connect_documentChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfBookmarkModel_documentChanged +func miqt_exec_callback_QPdfBookmarkModel_documentChanged(cb C.intptr_t, document *C.QPdfDocument) { + gofunc, ok := cgo.Handle(cb).Value().(func(document *QPdfDocument)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQPdfDocument(document) + + gofunc(slotval1) +} + +func QPdfBookmarkModel_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfBookmarkModel_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfBookmarkModel_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfBookmarkModel_tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +// CreateIndex can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) CreateIndex(row int, column int) qt6.QModelIndex { + + var _dynamic_cast_ok C.bool = false + _goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_protectedbase_createIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h), (C.int)(row), (C.int)(column)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _method_ret := *_goptr + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// EncodeData can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EncodeData(indexes []qt6.QModelIndex, stream *qt6.QDataStream) { + indexes_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(indexes)))) + defer C.free(unsafe.Pointer(indexes_CArray)) + for i := range indexes { + indexes_CArray[i] = (*C.QModelIndex)(indexes[i].UnsafePointer()) + } + indexes_ma := C.struct_miqt_array{len: C.size_t(len(indexes)), data: unsafe.Pointer(indexes_CArray)} + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_encodeData(&_dynamic_cast_ok, unsafe.Pointer(this.h), indexes_ma, (*C.QDataStream)(stream.UnsafePointer())) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// DecodeData can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) DecodeData(row int, column int, parent *qt6.QModelIndex, stream *qt6.QDataStream) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfBookmarkModel_protectedbase_decodeData(&_dynamic_cast_ok, unsafe.Pointer(this.h), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer()), (*C.QDataStream)(stream.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// BeginInsertRows can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginInsertRows(parent *qt6.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_beginInsertRows(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndInsertRows can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndInsertRows() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endInsertRows(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginRemoveRows can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginRemoveRows(parent *qt6.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_beginRemoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndRemoveRows can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndRemoveRows() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endRemoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginMoveRows can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginMoveRows(sourceParent *qt6.QModelIndex, sourceFirst int, sourceLast int, destinationParent *qt6.QModelIndex, destinationRow int) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfBookmarkModel_protectedbase_beginMoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceFirst), (C.int)(sourceLast), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationRow))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// EndMoveRows can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndMoveRows() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endMoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginInsertColumns can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginInsertColumns(parent *qt6.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_beginInsertColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndInsertColumns can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndInsertColumns() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endInsertColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginRemoveColumns can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginRemoveColumns(parent *qt6.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_beginRemoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndRemoveColumns can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndRemoveColumns() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endRemoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginMoveColumns can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginMoveColumns(sourceParent *qt6.QModelIndex, sourceFirst int, sourceLast int, destinationParent *qt6.QModelIndex, destinationColumn int) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfBookmarkModel_protectedbase_beginMoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceFirst), (C.int)(sourceLast), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationColumn))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// EndMoveColumns can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndMoveColumns() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endMoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginResetModel can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) BeginResetModel() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_beginResetModel(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndResetModel can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) EndResetModel() { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_endResetModel(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// ChangePersistentIndex can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) ChangePersistentIndex(from *qt6.QModelIndex, to *qt6.QModelIndex) { + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_changePersistentIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(from.UnsafePointer()), (*C.QModelIndex)(to.UnsafePointer())) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// ChangePersistentIndexList can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) ChangePersistentIndexList(from []qt6.QModelIndex, to []qt6.QModelIndex) { + from_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(from)))) + defer C.free(unsafe.Pointer(from_CArray)) + for i := range from { + from_CArray[i] = (*C.QModelIndex)(from[i].UnsafePointer()) + } + from_ma := C.struct_miqt_array{len: C.size_t(len(from)), data: unsafe.Pointer(from_CArray)} + to_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(to)))) + defer C.free(unsafe.Pointer(to_CArray)) + for i := range to { + to_CArray[i] = (*C.QModelIndex)(to[i].UnsafePointer()) + } + to_ma := C.struct_miqt_array{len: C.size_t(len(to)), data: unsafe.Pointer(to_CArray)} + + var _dynamic_cast_ok C.bool = false + C.QPdfBookmarkModel_protectedbase_changePersistentIndexList(&_dynamic_cast_ok, unsafe.Pointer(this.h), from_ma, to_ma) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// PersistentIndexList can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) PersistentIndexList() []qt6.QModelIndex { + + var _dynamic_cast_ok C.bool = false + var _ma C.struct_miqt_array = C.QPdfBookmarkModel_protectedbase_persistentIndexList(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + _ret := make([]qt6.QModelIndex, int(_ma.len)) + _outCast := (*[0xffff]*C.QModelIndex)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(_outCast[i])) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + _method_ret := _ret + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Sender can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QPdfBookmarkModel_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// SenderSignalIndex can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfBookmarkModel_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Receivers can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) Receivers(signal string) int { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfBookmarkModel_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// IsSignalConnected can only be called from a QPdfBookmarkModel that was directly constructed. +func (this *QPdfBookmarkModel) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfBookmarkModel_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Data(index *qt6.QModelIndex, role int) *qt6.QVariant { + + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_data(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), (C.int)(role)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnData(slot func(super func(index *qt6.QModelIndex, role int) *qt6.QVariant, index *qt6.QModelIndex, role int) *qt6.QVariant) { + ok := C.QPdfBookmarkModel_override_virtual_data(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_data +func miqt_exec_callback_QPdfBookmarkModel_data(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex, role C.int) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex, role int) *qt6.QVariant, index *qt6.QModelIndex, role int) *qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + slotval2 := (int)(role) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Data, slotval1, slotval2) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Index(row int, column int, parent *qt6.QModelIndex) *qt6.QModelIndex { + + _goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_index(unsafe.Pointer(this.h), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnIndex(slot func(super func(row int, column int, parent *qt6.QModelIndex) *qt6.QModelIndex, row int, column int, parent *qt6.QModelIndex) *qt6.QModelIndex) { + ok := C.QPdfBookmarkModel_override_virtual_index(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_index +func miqt_exec_callback_QPdfBookmarkModel_index(self *C.QPdfBookmarkModel, cb C.intptr_t, row C.int, column C.int, parent *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, column int, parent *qt6.QModelIndex) *qt6.QModelIndex, row int, column int, parent *qt6.QModelIndex) *qt6.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(column) + + slotval3 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Index, slotval1, slotval2, slotval3) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Parent(index *qt6.QModelIndex) *qt6.QModelIndex { + + _goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_parent(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnParent(slot func(super func(index *qt6.QModelIndex) *qt6.QModelIndex, index *qt6.QModelIndex) *qt6.QModelIndex) { + ok := C.QPdfBookmarkModel_override_virtual_parent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_parent +func miqt_exec_callback_QPdfBookmarkModel_parent(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex) *qt6.QModelIndex, index *qt6.QModelIndex) *qt6.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Parent, slotval1) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_RowCount(parent *qt6.QModelIndex) int { + + return (int)(C.QPdfBookmarkModel_virtualbase_rowCount(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnRowCount(slot func(super func(parent *qt6.QModelIndex) int, parent *qt6.QModelIndex) int) { + ok := C.QPdfBookmarkModel_override_virtual_rowCount(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_rowCount +func miqt_exec_callback_QPdfBookmarkModel_rowCount(self *C.QPdfBookmarkModel, cb C.intptr_t, parent *C.QModelIndex) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt6.QModelIndex) int, parent *qt6.QModelIndex) int) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_RowCount, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_ColumnCount(parent *qt6.QModelIndex) int { + + return (int)(C.QPdfBookmarkModel_virtualbase_columnCount(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnColumnCount(slot func(super func(parent *qt6.QModelIndex) int, parent *qt6.QModelIndex) int) { + ok := C.QPdfBookmarkModel_override_virtual_columnCount(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_columnCount +func miqt_exec_callback_QPdfBookmarkModel_columnCount(self *C.QPdfBookmarkModel, cb C.intptr_t, parent *C.QModelIndex) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt6.QModelIndex) int, parent *qt6.QModelIndex) int) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_ColumnCount, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_RoleNames() map[int][]byte { + + var _mm C.struct_miqt_map = C.QPdfBookmarkModel_virtualbase_roleNames(unsafe.Pointer(this.h)) + _ret := make(map[int][]byte, int(_mm.len)) + _Keys := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + _entry_Key := (int)(_Keys[i]) + + var _hashval_bytearray C.struct_miqt_string = _Values[i] + _hashval_ret := C.GoBytes(unsafe.Pointer(_hashval_bytearray.data), C.int(int64(_hashval_bytearray.len))) + C.free(unsafe.Pointer(_hashval_bytearray.data)) + _entry_Value := _hashval_ret + _ret[_entry_Key] = _entry_Value + } + return _ret + +} +func (this *QPdfBookmarkModel) OnRoleNames(slot func(super func() map[int][]byte) map[int][]byte) { + ok := C.QPdfBookmarkModel_override_virtual_roleNames(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_roleNames +func miqt_exec_callback_QPdfBookmarkModel_roleNames(self *C.QPdfBookmarkModel, cb C.intptr_t) C.struct_miqt_map { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() map[int][]byte) map[int][]byte) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_RoleNames) + virtualReturn_Keys_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Keys_CArray)) + virtualReturn_Values_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Values_CArray)) + virtualReturn_ctr := 0 + for virtualReturn_k, virtualReturn_v := range virtualReturn { + virtualReturn_Keys_CArray[virtualReturn_ctr] = (C.int)(virtualReturn_k) + virtualReturn_v_alias := C.struct_miqt_string{} + if len(virtualReturn_v) > 0 { + virtualReturn_v_alias.data = (*C.char)(unsafe.Pointer(&virtualReturn_v[0])) + } else { + virtualReturn_v_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + virtualReturn_v_alias.len = C.size_t(len(virtualReturn_v)) + virtualReturn_Values_CArray[virtualReturn_ctr] = virtualReturn_v_alias + virtualReturn_ctr++ + } + virtualReturn_mm := C.struct_miqt_map{ + len: C.size_t(len(virtualReturn)), + keys: unsafe.Pointer(virtualReturn_Keys_CArray), + values: unsafe.Pointer(virtualReturn_Values_CArray), + } + + return virtualReturn_mm + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Sibling(row int, column int, idx *qt6.QModelIndex) *qt6.QModelIndex { + + _goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_sibling(unsafe.Pointer(this.h), (C.int)(row), (C.int)(column), (*C.QModelIndex)(idx.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnSibling(slot func(super func(row int, column int, idx *qt6.QModelIndex) *qt6.QModelIndex, row int, column int, idx *qt6.QModelIndex) *qt6.QModelIndex) { + ok := C.QPdfBookmarkModel_override_virtual_sibling(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_sibling +func miqt_exec_callback_QPdfBookmarkModel_sibling(self *C.QPdfBookmarkModel, cb C.intptr_t, row C.int, column C.int, idx *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, column int, idx *qt6.QModelIndex) *qt6.QModelIndex, row int, column int, idx *qt6.QModelIndex) *qt6.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(column) + + slotval3 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(idx)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Sibling, slotval1, slotval2, slotval3) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_HasChildren(parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_hasChildren(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnHasChildren(slot func(super func(parent *qt6.QModelIndex) bool, parent *qt6.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_hasChildren(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_hasChildren +func miqt_exec_callback_QPdfBookmarkModel_hasChildren(self *C.QPdfBookmarkModel, cb C.intptr_t, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt6.QModelIndex) bool, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_HasChildren, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_SetData(index *qt6.QModelIndex, value *qt6.QVariant, role int) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_setData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), (*C.QVariant)(value.UnsafePointer()), (C.int)(role))) + +} +func (this *QPdfBookmarkModel) OnSetData(slot func(super func(index *qt6.QModelIndex, value *qt6.QVariant, role int) bool, index *qt6.QModelIndex, value *qt6.QVariant, role int) bool) { + ok := C.QPdfBookmarkModel_override_virtual_setData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_setData +func miqt_exec_callback_QPdfBookmarkModel_setData(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex, value *C.QVariant, role C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex, value *qt6.QVariant, role int) bool, index *qt6.QModelIndex, value *qt6.QVariant, role int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + slotval2 := qt6.UnsafeNewQVariant(unsafe.Pointer(value)) + + slotval3 := (int)(role) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_SetData, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_HeaderData(section int, orientation qt6.Orientation, role int) *qt6.QVariant { + + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_headerData(unsafe.Pointer(this.h), (C.int)(section), (C.int)(orientation), (C.int)(role)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnHeaderData(slot func(super func(section int, orientation qt6.Orientation, role int) *qt6.QVariant, section int, orientation qt6.Orientation, role int) *qt6.QVariant) { + ok := C.QPdfBookmarkModel_override_virtual_headerData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_headerData +func miqt_exec_callback_QPdfBookmarkModel_headerData(self *C.QPdfBookmarkModel, cb C.intptr_t, section C.int, orientation C.int, role C.int) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(section int, orientation qt6.Orientation, role int) *qt6.QVariant, section int, orientation qt6.Orientation, role int) *qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(section) + + slotval2 := (qt6.Orientation)(orientation) + + slotval3 := (int)(role) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_HeaderData, slotval1, slotval2, slotval3) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_SetHeaderData(section int, orientation qt6.Orientation, value *qt6.QVariant, role int) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_setHeaderData(unsafe.Pointer(this.h), (C.int)(section), (C.int)(orientation), (*C.QVariant)(value.UnsafePointer()), (C.int)(role))) + +} +func (this *QPdfBookmarkModel) OnSetHeaderData(slot func(super func(section int, orientation qt6.Orientation, value *qt6.QVariant, role int) bool, section int, orientation qt6.Orientation, value *qt6.QVariant, role int) bool) { + ok := C.QPdfBookmarkModel_override_virtual_setHeaderData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_setHeaderData +func miqt_exec_callback_QPdfBookmarkModel_setHeaderData(self *C.QPdfBookmarkModel, cb C.intptr_t, section C.int, orientation C.int, value *C.QVariant, role C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(section int, orientation qt6.Orientation, value *qt6.QVariant, role int) bool, section int, orientation qt6.Orientation, value *qt6.QVariant, role int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(section) + + slotval2 := (qt6.Orientation)(orientation) + + slotval3 := qt6.UnsafeNewQVariant(unsafe.Pointer(value)) + + slotval4 := (int)(role) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_SetHeaderData, slotval1, slotval2, slotval3, slotval4) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_ItemData(index *qt6.QModelIndex) map[int]qt6.QVariant { + + var _mm C.struct_miqt_map = C.QPdfBookmarkModel_virtualbase_itemData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())) + _ret := make(map[int]qt6.QVariant, int(_mm.len)) + _Keys := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + _entry_Key := (int)(_Keys[i]) + + _mapval_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(_Values[i])) + _mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _entry_Value := *_mapval_goptr + + _ret[_entry_Key] = _entry_Value + } + return _ret + +} +func (this *QPdfBookmarkModel) OnItemData(slot func(super func(index *qt6.QModelIndex) map[int]qt6.QVariant, index *qt6.QModelIndex) map[int]qt6.QVariant) { + ok := C.QPdfBookmarkModel_override_virtual_itemData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_itemData +func miqt_exec_callback_QPdfBookmarkModel_itemData(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex) C.struct_miqt_map { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex) map[int]qt6.QVariant, index *qt6.QModelIndex) map[int]qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_ItemData, slotval1) + virtualReturn_Keys_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Keys_CArray)) + virtualReturn_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Values_CArray)) + virtualReturn_ctr := 0 + for virtualReturn_k, virtualReturn_v := range virtualReturn { + virtualReturn_Keys_CArray[virtualReturn_ctr] = (C.int)(virtualReturn_k) + virtualReturn_Values_CArray[virtualReturn_ctr] = (*C.QVariant)(virtualReturn_v.UnsafePointer()) + virtualReturn_ctr++ + } + virtualReturn_mm := C.struct_miqt_map{ + len: C.size_t(len(virtualReturn)), + keys: unsafe.Pointer(virtualReturn_Keys_CArray), + values: unsafe.Pointer(virtualReturn_Values_CArray), + } + + return virtualReturn_mm + +} + +func (this *QPdfBookmarkModel) callVirtualBase_SetItemData(index *qt6.QModelIndex, roles map[int]qt6.QVariant) bool { + roles_Keys_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(roles)))) + defer C.free(unsafe.Pointer(roles_Keys_CArray)) + roles_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(roles)))) + defer C.free(unsafe.Pointer(roles_Values_CArray)) + roles_ctr := 0 + for roles_k, roles_v := range roles { + roles_Keys_CArray[roles_ctr] = (C.int)(roles_k) + roles_Values_CArray[roles_ctr] = (*C.QVariant)(roles_v.UnsafePointer()) + roles_ctr++ + } + roles_mm := C.struct_miqt_map{ + len: C.size_t(len(roles)), + keys: unsafe.Pointer(roles_Keys_CArray), + values: unsafe.Pointer(roles_Values_CArray), + } + + return (bool)(C.QPdfBookmarkModel_virtualbase_setItemData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), roles_mm)) + +} +func (this *QPdfBookmarkModel) OnSetItemData(slot func(super func(index *qt6.QModelIndex, roles map[int]qt6.QVariant) bool, index *qt6.QModelIndex, roles map[int]qt6.QVariant) bool) { + ok := C.QPdfBookmarkModel_override_virtual_setItemData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_setItemData +func miqt_exec_callback_QPdfBookmarkModel_setItemData(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex, roles C.struct_miqt_map) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex, roles map[int]qt6.QVariant) bool, index *qt6.QModelIndex, roles map[int]qt6.QVariant) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + var roles_mm C.struct_miqt_map = roles + roles_ret := make(map[int]qt6.QVariant, int(roles_mm.len)) + roles_Keys := (*[0xffff]C.int)(unsafe.Pointer(roles_mm.keys)) + roles_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(roles_mm.values)) + for i := 0; i < int(roles_mm.len); i++ { + roles_entry_Key := (int)(roles_Keys[i]) + + roles_mapval_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(roles_Values[i])) + roles_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + roles_entry_Value := *roles_mapval_goptr + + roles_ret[roles_entry_Key] = roles_entry_Value + } + slotval2 := roles_ret + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_SetItemData, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_ClearItemData(index *qt6.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_clearItemData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnClearItemData(slot func(super func(index *qt6.QModelIndex) bool, index *qt6.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_clearItemData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_clearItemData +func miqt_exec_callback_QPdfBookmarkModel_clearItemData(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex) bool, index *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_ClearItemData, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_MimeTypes() []string { + + var _ma C.struct_miqt_array = C.QPdfBookmarkModel_virtualbase_mimeTypes(unsafe.Pointer(this.h)) + _ret := make([]string, int(_ma.len)) + _outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + var _lv_ms C.struct_miqt_string = _outCast[i] + _lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len))) + C.free(unsafe.Pointer(_lv_ms.data)) + _ret[i] = _lv_ret + } + return _ret + +} +func (this *QPdfBookmarkModel) OnMimeTypes(slot func(super func() []string) []string) { + ok := C.QPdfBookmarkModel_override_virtual_mimeTypes(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_mimeTypes +func miqt_exec_callback_QPdfBookmarkModel_mimeTypes(self *C.QPdfBookmarkModel, cb C.intptr_t) C.struct_miqt_array { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() []string) []string) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_MimeTypes) + virtualReturn_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_CArray)) + for i := range virtualReturn { + virtualReturn_i_ms := C.struct_miqt_string{} + virtualReturn_i_ms.data = C.CString(virtualReturn[i]) + virtualReturn_i_ms.len = C.size_t(len(virtualReturn[i])) + defer C.free(unsafe.Pointer(virtualReturn_i_ms.data)) + virtualReturn_CArray[i] = virtualReturn_i_ms + } + virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)} + + return virtualReturn_ma + +} + +func (this *QPdfBookmarkModel) callVirtualBase_MimeData(indexes []qt6.QModelIndex) *qt6.QMimeData { + indexes_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(indexes)))) + defer C.free(unsafe.Pointer(indexes_CArray)) + for i := range indexes { + indexes_CArray[i] = (*C.QModelIndex)(indexes[i].UnsafePointer()) + } + indexes_ma := C.struct_miqt_array{len: C.size_t(len(indexes)), data: unsafe.Pointer(indexes_CArray)} + + return qt6.UnsafeNewQMimeData(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_mimeData(unsafe.Pointer(this.h), indexes_ma))) + +} +func (this *QPdfBookmarkModel) OnMimeData(slot func(super func(indexes []qt6.QModelIndex) *qt6.QMimeData, indexes []qt6.QModelIndex) *qt6.QMimeData) { + ok := C.QPdfBookmarkModel_override_virtual_mimeData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_mimeData +func miqt_exec_callback_QPdfBookmarkModel_mimeData(self *C.QPdfBookmarkModel, cb C.intptr_t, indexes C.struct_miqt_array) *C.QMimeData { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(indexes []qt6.QModelIndex) *qt6.QMimeData, indexes []qt6.QModelIndex) *qt6.QMimeData) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var indexes_ma C.struct_miqt_array = indexes + indexes_ret := make([]qt6.QModelIndex, int(indexes_ma.len)) + indexes_outCast := (*[0xffff]*C.QModelIndex)(unsafe.Pointer(indexes_ma.data)) // hey ya + for i := 0; i < int(indexes_ma.len); i++ { + indexes_lv_goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(indexes_outCast[i])) + indexes_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + indexes_ret[i] = *indexes_lv_goptr + } + slotval1 := indexes_ret + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_MimeData, slotval1) + + return (*C.QMimeData)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_CanDropMimeData(data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_canDropMimeData(unsafe.Pointer(this.h), (*C.QMimeData)(data.UnsafePointer()), (C.int)(action), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnCanDropMimeData(slot func(super func(data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool, data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_canDropMimeData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_canDropMimeData +func miqt_exec_callback_QPdfBookmarkModel_canDropMimeData(self *C.QPdfBookmarkModel, cb C.intptr_t, data *C.QMimeData, action C.int, row C.int, column C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool, data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMimeData(unsafe.Pointer(data)) + + slotval2 := (qt6.DropAction)(action) + + slotval3 := (int)(row) + + slotval4 := (int)(column) + + slotval5 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_CanDropMimeData, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_DropMimeData(data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_dropMimeData(unsafe.Pointer(this.h), (*C.QMimeData)(data.UnsafePointer()), (C.int)(action), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnDropMimeData(slot func(super func(data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool, data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_dropMimeData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_dropMimeData +func miqt_exec_callback_QPdfBookmarkModel_dropMimeData(self *C.QPdfBookmarkModel, cb C.intptr_t, data *C.QMimeData, action C.int, row C.int, column C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool, data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMimeData(unsafe.Pointer(data)) + + slotval2 := (qt6.DropAction)(action) + + slotval3 := (int)(row) + + slotval4 := (int)(column) + + slotval5 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_DropMimeData, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_SupportedDropActions() qt6.DropAction { + + return (qt6.DropAction)(C.QPdfBookmarkModel_virtualbase_supportedDropActions(unsafe.Pointer(this.h))) + +} +func (this *QPdfBookmarkModel) OnSupportedDropActions(slot func(super func() qt6.DropAction) qt6.DropAction) { + ok := C.QPdfBookmarkModel_override_virtual_supportedDropActions(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_supportedDropActions +func miqt_exec_callback_QPdfBookmarkModel_supportedDropActions(self *C.QPdfBookmarkModel, cb C.intptr_t) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() qt6.DropAction) qt6.DropAction) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_SupportedDropActions) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_SupportedDragActions() qt6.DropAction { + + return (qt6.DropAction)(C.QPdfBookmarkModel_virtualbase_supportedDragActions(unsafe.Pointer(this.h))) + +} +func (this *QPdfBookmarkModel) OnSupportedDragActions(slot func(super func() qt6.DropAction) qt6.DropAction) { + ok := C.QPdfBookmarkModel_override_virtual_supportedDragActions(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_supportedDragActions +func miqt_exec_callback_QPdfBookmarkModel_supportedDragActions(self *C.QPdfBookmarkModel, cb C.intptr_t) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() qt6.DropAction) qt6.DropAction) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_SupportedDragActions) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_InsertRows(row int, count int, parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_insertRows(unsafe.Pointer(this.h), (C.int)(row), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnInsertRows(slot func(super func(row int, count int, parent *qt6.QModelIndex) bool, row int, count int, parent *qt6.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_insertRows(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_insertRows +func miqt_exec_callback_QPdfBookmarkModel_insertRows(self *C.QPdfBookmarkModel, cb C.intptr_t, row C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, count int, parent *qt6.QModelIndex) bool, row int, count int, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(count) + + slotval3 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_InsertRows, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_InsertColumns(column int, count int, parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_insertColumns(unsafe.Pointer(this.h), (C.int)(column), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnInsertColumns(slot func(super func(column int, count int, parent *qt6.QModelIndex) bool, column int, count int, parent *qt6.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_insertColumns(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_insertColumns +func miqt_exec_callback_QPdfBookmarkModel_insertColumns(self *C.QPdfBookmarkModel, cb C.intptr_t, column C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(column int, count int, parent *qt6.QModelIndex) bool, column int, count int, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(column) + + slotval2 := (int)(count) + + slotval3 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_InsertColumns, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_RemoveRows(row int, count int, parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_removeRows(unsafe.Pointer(this.h), (C.int)(row), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnRemoveRows(slot func(super func(row int, count int, parent *qt6.QModelIndex) bool, row int, count int, parent *qt6.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_removeRows(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_removeRows +func miqt_exec_callback_QPdfBookmarkModel_removeRows(self *C.QPdfBookmarkModel, cb C.intptr_t, row C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, count int, parent *qt6.QModelIndex) bool, row int, count int, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(count) + + slotval3 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_RemoveRows, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_RemoveColumns(column int, count int, parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_removeColumns(unsafe.Pointer(this.h), (C.int)(column), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnRemoveColumns(slot func(super func(column int, count int, parent *qt6.QModelIndex) bool, column int, count int, parent *qt6.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_removeColumns(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_removeColumns +func miqt_exec_callback_QPdfBookmarkModel_removeColumns(self *C.QPdfBookmarkModel, cb C.intptr_t, column C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(column int, count int, parent *qt6.QModelIndex) bool, column int, count int, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(column) + + slotval2 := (int)(count) + + slotval3 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_RemoveColumns, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_MoveRows(sourceParent *qt6.QModelIndex, sourceRow int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_moveRows(unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceRow), (C.int)(count), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationChild))) + +} +func (this *QPdfBookmarkModel) OnMoveRows(slot func(super func(sourceParent *qt6.QModelIndex, sourceRow int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool, sourceParent *qt6.QModelIndex, sourceRow int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool) { + ok := C.QPdfBookmarkModel_override_virtual_moveRows(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_moveRows +func miqt_exec_callback_QPdfBookmarkModel_moveRows(self *C.QPdfBookmarkModel, cb C.intptr_t, sourceParent *C.QModelIndex, sourceRow C.int, count C.int, destinationParent *C.QModelIndex, destinationChild C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(sourceParent *qt6.QModelIndex, sourceRow int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool, sourceParent *qt6.QModelIndex, sourceRow int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(sourceParent)) + + slotval2 := (int)(sourceRow) + + slotval3 := (int)(count) + + slotval4 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(destinationParent)) + + slotval5 := (int)(destinationChild) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_MoveRows, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_MoveColumns(sourceParent *qt6.QModelIndex, sourceColumn int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_moveColumns(unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceColumn), (C.int)(count), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationChild))) + +} +func (this *QPdfBookmarkModel) OnMoveColumns(slot func(super func(sourceParent *qt6.QModelIndex, sourceColumn int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool, sourceParent *qt6.QModelIndex, sourceColumn int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool) { + ok := C.QPdfBookmarkModel_override_virtual_moveColumns(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_moveColumns +func miqt_exec_callback_QPdfBookmarkModel_moveColumns(self *C.QPdfBookmarkModel, cb C.intptr_t, sourceParent *C.QModelIndex, sourceColumn C.int, count C.int, destinationParent *C.QModelIndex, destinationChild C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(sourceParent *qt6.QModelIndex, sourceColumn int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool, sourceParent *qt6.QModelIndex, sourceColumn int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(sourceParent)) + + slotval2 := (int)(sourceColumn) + + slotval3 := (int)(count) + + slotval4 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(destinationParent)) + + slotval5 := (int)(destinationChild) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_MoveColumns, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_FetchMore(parent *qt6.QModelIndex) { + + C.QPdfBookmarkModel_virtualbase_fetchMore(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnFetchMore(slot func(super func(parent *qt6.QModelIndex), parent *qt6.QModelIndex)) { + ok := C.QPdfBookmarkModel_override_virtual_fetchMore(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_fetchMore +func miqt_exec_callback_QPdfBookmarkModel_fetchMore(self *C.QPdfBookmarkModel, cb C.intptr_t, parent *C.QModelIndex) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt6.QModelIndex), parent *qt6.QModelIndex)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_FetchMore, slotval1) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_CanFetchMore(parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_canFetchMore(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnCanFetchMore(slot func(super func(parent *qt6.QModelIndex) bool, parent *qt6.QModelIndex) bool) { + ok := C.QPdfBookmarkModel_override_virtual_canFetchMore(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_canFetchMore +func miqt_exec_callback_QPdfBookmarkModel_canFetchMore(self *C.QPdfBookmarkModel, cb C.intptr_t, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt6.QModelIndex) bool, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_CanFetchMore, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Flags(index *qt6.QModelIndex) qt6.ItemFlag { + + return (qt6.ItemFlag)(C.QPdfBookmarkModel_virtualbase_flags(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnFlags(slot func(super func(index *qt6.QModelIndex) qt6.ItemFlag, index *qt6.QModelIndex) qt6.ItemFlag) { + ok := C.QPdfBookmarkModel_override_virtual_flags(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_flags +func miqt_exec_callback_QPdfBookmarkModel_flags(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex) qt6.ItemFlag, index *qt6.QModelIndex) qt6.ItemFlag) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Flags, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Sort(column int, order qt6.SortOrder) { + + C.QPdfBookmarkModel_virtualbase_sort(unsafe.Pointer(this.h), (C.int)(column), (C.int)(order)) + +} +func (this *QPdfBookmarkModel) OnSort(slot func(super func(column int, order qt6.SortOrder), column int, order qt6.SortOrder)) { + ok := C.QPdfBookmarkModel_override_virtual_sort(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_sort +func miqt_exec_callback_QPdfBookmarkModel_sort(self *C.QPdfBookmarkModel, cb C.intptr_t, column C.int, order C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(column int, order qt6.SortOrder), column int, order qt6.SortOrder)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(column) + + slotval2 := (qt6.SortOrder)(order) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Sort, slotval1, slotval2) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Buddy(index *qt6.QModelIndex) *qt6.QModelIndex { + + _goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_buddy(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnBuddy(slot func(super func(index *qt6.QModelIndex) *qt6.QModelIndex, index *qt6.QModelIndex) *qt6.QModelIndex) { + ok := C.QPdfBookmarkModel_override_virtual_buddy(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_buddy +func miqt_exec_callback_QPdfBookmarkModel_buddy(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex) *qt6.QModelIndex, index *qt6.QModelIndex) *qt6.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Buddy, slotval1) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Match(start *qt6.QModelIndex, role int, value *qt6.QVariant, hits int, flags qt6.MatchFlag) []qt6.QModelIndex { + + var _ma C.struct_miqt_array = C.QPdfBookmarkModel_virtualbase_match(unsafe.Pointer(this.h), (*C.QModelIndex)(start.UnsafePointer()), (C.int)(role), (*C.QVariant)(value.UnsafePointer()), (C.int)(hits), (C.int)(flags)) + _ret := make([]qt6.QModelIndex, int(_ma.len)) + _outCast := (*[0xffff]*C.QModelIndex)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(_outCast[i])) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret + +} +func (this *QPdfBookmarkModel) OnMatch(slot func(super func(start *qt6.QModelIndex, role int, value *qt6.QVariant, hits int, flags qt6.MatchFlag) []qt6.QModelIndex, start *qt6.QModelIndex, role int, value *qt6.QVariant, hits int, flags qt6.MatchFlag) []qt6.QModelIndex) { + ok := C.QPdfBookmarkModel_override_virtual_match(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_match +func miqt_exec_callback_QPdfBookmarkModel_match(self *C.QPdfBookmarkModel, cb C.intptr_t, start *C.QModelIndex, role C.int, value *C.QVariant, hits C.int, flags C.int) C.struct_miqt_array { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(start *qt6.QModelIndex, role int, value *qt6.QVariant, hits int, flags qt6.MatchFlag) []qt6.QModelIndex, start *qt6.QModelIndex, role int, value *qt6.QVariant, hits int, flags qt6.MatchFlag) []qt6.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(start)) + + slotval2 := (int)(role) + + slotval3 := qt6.UnsafeNewQVariant(unsafe.Pointer(value)) + + slotval4 := (int)(hits) + + slotval5 := (qt6.MatchFlag)(flags) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Match, slotval1, slotval2, slotval3, slotval4, slotval5) + virtualReturn_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_CArray)) + for i := range virtualReturn { + virtualReturn_CArray[i] = (*C.QModelIndex)(virtualReturn[i].UnsafePointer()) + } + virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)} + + return virtualReturn_ma + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Span(index *qt6.QModelIndex) *qt6.QSize { + + _goptr := qt6.UnsafeNewQSize(unsafe.Pointer(C.QPdfBookmarkModel_virtualbase_span(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfBookmarkModel) OnSpan(slot func(super func(index *qt6.QModelIndex) *qt6.QSize, index *qt6.QModelIndex) *qt6.QSize) { + ok := C.QPdfBookmarkModel_override_virtual_span(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_span +func miqt_exec_callback_QPdfBookmarkModel_span(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex) *C.QSize { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex) *qt6.QSize, index *qt6.QModelIndex) *qt6.QSize) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Span, slotval1) + + return (*C.QSize)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_MultiData(index *qt6.QModelIndex, roleDataSpan qt6.QModelRoleDataSpan) { + + C.QPdfBookmarkModel_virtualbase_multiData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), (*C.QModelRoleDataSpan)(roleDataSpan.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnMultiData(slot func(super func(index *qt6.QModelIndex, roleDataSpan qt6.QModelRoleDataSpan), index *qt6.QModelIndex, roleDataSpan qt6.QModelRoleDataSpan)) { + ok := C.QPdfBookmarkModel_override_virtual_multiData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_multiData +func miqt_exec_callback_QPdfBookmarkModel_multiData(self *C.QPdfBookmarkModel, cb C.intptr_t, index *C.QModelIndex, roleDataSpan *C.QModelRoleDataSpan) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex, roleDataSpan qt6.QModelRoleDataSpan), index *qt6.QModelIndex, roleDataSpan qt6.QModelRoleDataSpan)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + roleDataSpan_goptr := qt6.UnsafeNewQModelRoleDataSpan(unsafe.Pointer(roleDataSpan)) + roleDataSpan_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + slotval2 := *roleDataSpan_goptr + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_MultiData, slotval1, slotval2) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Submit() bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_submit(unsafe.Pointer(this.h))) + +} +func (this *QPdfBookmarkModel) OnSubmit(slot func(super func() bool) bool) { + ok := C.QPdfBookmarkModel_override_virtual_submit(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_submit +func miqt_exec_callback_QPdfBookmarkModel_submit(self *C.QPdfBookmarkModel, cb C.intptr_t) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Submit) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Revert() { + + C.QPdfBookmarkModel_virtualbase_revert(unsafe.Pointer(this.h)) + +} +func (this *QPdfBookmarkModel) OnRevert(slot func(super func())) { + ok := C.QPdfBookmarkModel_override_virtual_revert(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_revert +func miqt_exec_callback_QPdfBookmarkModel_revert(self *C.QPdfBookmarkModel, cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func())) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Revert) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_ResetInternalData() { + + C.QPdfBookmarkModel_virtualbase_resetInternalData(unsafe.Pointer(this.h)) + +} +func (this *QPdfBookmarkModel) OnResetInternalData(slot func(super func())) { + ok := C.QPdfBookmarkModel_override_virtual_resetInternalData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_resetInternalData +func miqt_exec_callback_QPdfBookmarkModel_resetInternalData(self *C.QPdfBookmarkModel, cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func())) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_ResetInternalData) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QPdfBookmarkModel_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_event +func miqt_exec_callback_QPdfBookmarkModel_event(self *C.QPdfBookmarkModel, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QPdfBookmarkModel_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfBookmarkModel) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QPdfBookmarkModel_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_eventFilter +func miqt_exec_callback_QPdfBookmarkModel_eventFilter(self *C.QPdfBookmarkModel, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QPdfBookmarkModel_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QPdfBookmarkModel_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_timerEvent +func miqt_exec_callback_QPdfBookmarkModel_timerEvent(self *C.QPdfBookmarkModel, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QPdfBookmarkModel_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QPdfBookmarkModel_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_childEvent +func miqt_exec_callback_QPdfBookmarkModel_childEvent(self *C.QPdfBookmarkModel, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QPdfBookmarkModel_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QPdfBookmarkModel_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_customEvent +func miqt_exec_callback_QPdfBookmarkModel_customEvent(self *C.QPdfBookmarkModel, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent), event *qt6.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QPdfBookmarkModel_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QPdfBookmarkModel_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_connectNotify +func miqt_exec_callback_QPdfBookmarkModel_connectNotify(self *C.QPdfBookmarkModel, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QPdfBookmarkModel) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QPdfBookmarkModel_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfBookmarkModel) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QPdfBookmarkModel_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfBookmarkModel_disconnectNotify +func miqt_exec_callback_QPdfBookmarkModel_disconnectNotify(self *C.QPdfBookmarkModel, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfBookmarkModel{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QPdfBookmarkModel) Delete() { + C.QPdfBookmarkModel_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfBookmarkModel) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfBookmarkModel) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/pdf/gen_qpdfbookmarkmodel.h b/qt6/pdf/gen_qpdfbookmarkmodel.h new file mode 100644 index 00000000..e23351d6 --- /dev/null +++ b/qt6/pdf/gen_qpdfbookmarkmodel.h @@ -0,0 +1,187 @@ +#pragma once +#ifndef MIQT_QT6_PDF_GEN_QPDFBOOKMARKMODEL_H +#define MIQT_QT6_PDF_GEN_QPDFBOOKMARKMODEL_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractItemModel; +class QChildEvent; +class QDataStream; +class QEvent; +class QMetaMethod; +class QMetaObject; +class QMimeData; +class QModelIndex; +class QModelRoleDataSpan; +class QObject; +class QPdfBookmarkModel; +class QPdfDocument; +class QSize; +class QTimerEvent; +class QVariant; +#else +typedef struct QAbstractItemModel QAbstractItemModel; +typedef struct QChildEvent QChildEvent; +typedef struct QDataStream QDataStream; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QMimeData QMimeData; +typedef struct QModelIndex QModelIndex; +typedef struct QModelRoleDataSpan QModelRoleDataSpan; +typedef struct QObject QObject; +typedef struct QPdfBookmarkModel QPdfBookmarkModel; +typedef struct QPdfDocument QPdfDocument; +typedef struct QSize QSize; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +#endif + +QPdfBookmarkModel* QPdfBookmarkModel_new(); +QPdfBookmarkModel* QPdfBookmarkModel_new2(QObject* parent); +void QPdfBookmarkModel_virtbase(QPdfBookmarkModel* src, QAbstractItemModel** outptr_QAbstractItemModel); +QMetaObject* QPdfBookmarkModel_metaObject(const QPdfBookmarkModel* self); +void* QPdfBookmarkModel_metacast(QPdfBookmarkModel* self, const char* param1); +struct miqt_string QPdfBookmarkModel_tr(const char* s); +QPdfDocument* QPdfBookmarkModel_document(const QPdfBookmarkModel* self); +void QPdfBookmarkModel_setDocument(QPdfBookmarkModel* self, QPdfDocument* document); +QVariant* QPdfBookmarkModel_data(const QPdfBookmarkModel* self, QModelIndex* index, int role); +QModelIndex* QPdfBookmarkModel_index(const QPdfBookmarkModel* self, int row, int column, QModelIndex* parent); +QModelIndex* QPdfBookmarkModel_parent(const QPdfBookmarkModel* self, QModelIndex* index); +int QPdfBookmarkModel_rowCount(const QPdfBookmarkModel* self, QModelIndex* parent); +int QPdfBookmarkModel_columnCount(const QPdfBookmarkModel* self, QModelIndex* parent); +struct miqt_map /* of int to struct miqt_string */ QPdfBookmarkModel_roleNames(const QPdfBookmarkModel* self); +void QPdfBookmarkModel_documentChanged(QPdfBookmarkModel* self, QPdfDocument* document); +void QPdfBookmarkModel_connect_documentChanged(QPdfBookmarkModel* self, intptr_t slot); +struct miqt_string QPdfBookmarkModel_tr2(const char* s, const char* c); +struct miqt_string QPdfBookmarkModel_tr3(const char* s, const char* c, int n); +bool QPdfBookmarkModel_override_virtual_data(void* self, intptr_t slot); +QVariant* QPdfBookmarkModel_virtualbase_data(const void* self, QModelIndex* index, int role); +bool QPdfBookmarkModel_override_virtual_index(void* self, intptr_t slot); +QModelIndex* QPdfBookmarkModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_parent(void* self, intptr_t slot); +QModelIndex* QPdfBookmarkModel_virtualbase_parent(const void* self, QModelIndex* index); +bool QPdfBookmarkModel_override_virtual_rowCount(void* self, intptr_t slot); +int QPdfBookmarkModel_virtualbase_rowCount(const void* self, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_columnCount(void* self, intptr_t slot); +int QPdfBookmarkModel_virtualbase_columnCount(const void* self, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_roleNames(void* self, intptr_t slot); +struct miqt_map /* of int to struct miqt_string */ QPdfBookmarkModel_virtualbase_roleNames(const void* self); +bool QPdfBookmarkModel_override_virtual_sibling(void* self, intptr_t slot); +QModelIndex* QPdfBookmarkModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx); +bool QPdfBookmarkModel_override_virtual_hasChildren(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_hasChildren(const void* self, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_setData(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role); +bool QPdfBookmarkModel_override_virtual_headerData(void* self, intptr_t slot); +QVariant* QPdfBookmarkModel_virtualbase_headerData(const void* self, int section, int orientation, int role); +bool QPdfBookmarkModel_override_virtual_setHeaderData(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role); +bool QPdfBookmarkModel_override_virtual_itemData(void* self, intptr_t slot); +struct miqt_map /* of int to QVariant* */ QPdfBookmarkModel_virtualbase_itemData(const void* self, QModelIndex* index); +bool QPdfBookmarkModel_override_virtual_setItemData(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */ roles); +bool QPdfBookmarkModel_override_virtual_clearItemData(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_clearItemData(void* self, QModelIndex* index); +bool QPdfBookmarkModel_override_virtual_mimeTypes(void* self, intptr_t slot); +struct miqt_array /* of struct miqt_string */ QPdfBookmarkModel_virtualbase_mimeTypes(const void* self); +bool QPdfBookmarkModel_override_virtual_mimeData(void* self, intptr_t slot); +QMimeData* QPdfBookmarkModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes); +bool QPdfBookmarkModel_override_virtual_canDropMimeData(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_dropMimeData(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_supportedDropActions(void* self, intptr_t slot); +int QPdfBookmarkModel_virtualbase_supportedDropActions(const void* self); +bool QPdfBookmarkModel_override_virtual_supportedDragActions(void* self, intptr_t slot); +int QPdfBookmarkModel_virtualbase_supportedDragActions(const void* self); +bool QPdfBookmarkModel_override_virtual_insertRows(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_insertColumns(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_removeRows(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_removeColumns(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_moveRows(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild); +bool QPdfBookmarkModel_override_virtual_moveColumns(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild); +bool QPdfBookmarkModel_override_virtual_fetchMore(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_fetchMore(void* self, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_canFetchMore(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent); +bool QPdfBookmarkModel_override_virtual_flags(void* self, intptr_t slot); +int QPdfBookmarkModel_virtualbase_flags(const void* self, QModelIndex* index); +bool QPdfBookmarkModel_override_virtual_sort(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_sort(void* self, int column, int order); +bool QPdfBookmarkModel_override_virtual_buddy(void* self, intptr_t slot); +QModelIndex* QPdfBookmarkModel_virtualbase_buddy(const void* self, QModelIndex* index); +bool QPdfBookmarkModel_override_virtual_match(void* self, intptr_t slot); +struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); +bool QPdfBookmarkModel_override_virtual_span(void* self, intptr_t slot); +QSize* QPdfBookmarkModel_virtualbase_span(const void* self, QModelIndex* index); +bool QPdfBookmarkModel_override_virtual_multiData(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_multiData(const void* self, QModelIndex* index, QModelRoleDataSpan* roleDataSpan); +bool QPdfBookmarkModel_override_virtual_submit(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_submit(void* self); +bool QPdfBookmarkModel_override_virtual_revert(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_revert(void* self); +bool QPdfBookmarkModel_override_virtual_resetInternalData(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_resetInternalData(void* self); +bool QPdfBookmarkModel_override_virtual_event(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_event(void* self, QEvent* event); +bool QPdfBookmarkModel_override_virtual_eventFilter(void* self, intptr_t slot); +bool QPdfBookmarkModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QPdfBookmarkModel_override_virtual_timerEvent(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QPdfBookmarkModel_override_virtual_childEvent(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_childEvent(void* self, QChildEvent* event); +bool QPdfBookmarkModel_override_virtual_customEvent(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_customEvent(void* self, QEvent* event); +bool QPdfBookmarkModel_override_virtual_connectNotify(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QPdfBookmarkModel_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QPdfBookmarkModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); +QModelIndex* QPdfBookmarkModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column); +void QPdfBookmarkModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */ indexes, QDataStream* stream); +bool QPdfBookmarkModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream); +void QPdfBookmarkModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfBookmarkModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self); +void QPdfBookmarkModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfBookmarkModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self); +bool QPdfBookmarkModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow); +void QPdfBookmarkModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self); +void QPdfBookmarkModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfBookmarkModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self); +void QPdfBookmarkModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfBookmarkModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self); +bool QPdfBookmarkModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn); +void QPdfBookmarkModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self); +void QPdfBookmarkModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self); +void QPdfBookmarkModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self); +void QPdfBookmarkModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to); +void QPdfBookmarkModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */ from, struct miqt_array /* of QModelIndex* */ to); +struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self); +QObject* QPdfBookmarkModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QPdfBookmarkModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QPdfBookmarkModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QPdfBookmarkModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +void QPdfBookmarkModel_delete(QPdfBookmarkModel* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/pdf/gen_qpdfdocument.cpp b/qt6/pdf/gen_qpdfdocument.cpp new file mode 100644 index 00000000..d06eb453 --- /dev/null +++ b/qt6/pdf/gen_qpdfdocument.cpp @@ -0,0 +1,554 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qpdfdocument.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QPdfDocument_passwordChanged(intptr_t); +void miqt_exec_callback_QPdfDocument_passwordRequired(intptr_t); +void miqt_exec_callback_QPdfDocument_statusChanged(intptr_t, int); +void miqt_exec_callback_QPdfDocument_pageCountChanged(intptr_t, int); +void miqt_exec_callback_QPdfDocument_pageModelChanged(intptr_t); +bool miqt_exec_callback_QPdfDocument_event(QPdfDocument*, intptr_t, QEvent*); +bool miqt_exec_callback_QPdfDocument_eventFilter(QPdfDocument*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QPdfDocument_timerEvent(QPdfDocument*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QPdfDocument_childEvent(QPdfDocument*, intptr_t, QChildEvent*); +void miqt_exec_callback_QPdfDocument_customEvent(QPdfDocument*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfDocument_connectNotify(QPdfDocument*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QPdfDocument_disconnectNotify(QPdfDocument*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQPdfDocument final : public QPdfDocument { +public: + + MiqtVirtualQPdfDocument(): QPdfDocument() {}; + MiqtVirtualQPdfDocument(QObject* parent): QPdfDocument(parent) {}; + + virtual ~MiqtVirtualQPdfDocument() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QPdfDocument::event(event); + } + + QEvent* sigval1 = event; + + bool callback_return_value = miqt_exec_callback_QPdfDocument_event(this, handle__event, sigval1); + + return callback_return_value; + } + + friend bool QPdfDocument_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QPdfDocument::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + + bool callback_return_value = miqt_exec_callback_QPdfDocument_eventFilter(this, handle__eventFilter, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfDocument_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__timerEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void timerEvent(QTimerEvent* event) override { + if (handle__timerEvent == 0) { + QPdfDocument::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + + miqt_exec_callback_QPdfDocument_timerEvent(this, handle__timerEvent, sigval1); + + + } + + friend void QPdfDocument_virtualbase_timerEvent(void* self, QTimerEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__childEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void childEvent(QChildEvent* event) override { + if (handle__childEvent == 0) { + QPdfDocument::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + + miqt_exec_callback_QPdfDocument_childEvent(this, handle__childEvent, sigval1); + + + } + + friend void QPdfDocument_virtualbase_childEvent(void* self, QChildEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__customEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void customEvent(QEvent* event) override { + if (handle__customEvent == 0) { + QPdfDocument::customEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfDocument_customEvent(this, handle__customEvent, sigval1); + + + } + + friend void QPdfDocument_virtualbase_customEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__connectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void connectNotify(const QMetaMethod& signal) override { + if (handle__connectNotify == 0) { + QPdfDocument::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfDocument_connectNotify(this, handle__connectNotify, sigval1); + + + } + + friend void QPdfDocument_virtualbase_connectNotify(void* self, QMetaMethod* signal); + + // cgo.Handle value for overwritten implementation + intptr_t handle__disconnectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void disconnectNotify(const QMetaMethod& signal) override { + if (handle__disconnectNotify == 0) { + QPdfDocument::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfDocument_disconnectNotify(this, handle__disconnectNotify, sigval1); + + + } + + friend void QPdfDocument_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QPdfDocument_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QPdfDocument_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QPdfDocument_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QPdfDocument_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QPdfDocument* QPdfDocument_new() { + return new MiqtVirtualQPdfDocument(); +} + +QPdfDocument* QPdfDocument_new2(QObject* parent) { + return new MiqtVirtualQPdfDocument(parent); +} + +void QPdfDocument_virtbase(QPdfDocument* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QPdfDocument_metaObject(const QPdfDocument* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QPdfDocument_metacast(QPdfDocument* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QPdfDocument_tr(const char* s) { + QString _ret = QPdfDocument::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; +} + +int QPdfDocument_load(QPdfDocument* self, struct miqt_string fileName) { + QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); + QPdfDocument::Error _ret = self->load(fileName_QString); + return static_cast(_ret); +} + +int QPdfDocument_status(const QPdfDocument* self) { + QPdfDocument::Status _ret = self->status(); + return static_cast(_ret); +} + +void QPdfDocument_loadWithDevice(QPdfDocument* self, QIODevice* device) { + self->load(device); +} + +void QPdfDocument_setPassword(QPdfDocument* self, struct miqt_string password) { + QString password_QString = QString::fromUtf8(password.data, password.len); + self->setPassword(password_QString); +} + +struct miqt_string QPdfDocument_password(const QPdfDocument* self) { + QString _ret = self->password(); + // 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; +} + +QVariant* QPdfDocument_metaData(const QPdfDocument* self, int field) { + return new QVariant(self->metaData(static_cast(field))); +} + +int QPdfDocument_error(const QPdfDocument* self) { + QPdfDocument::Error _ret = self->error(); + return static_cast(_ret); +} + +void QPdfDocument_close(QPdfDocument* self) { + self->close(); +} + +int QPdfDocument_pageCount(const QPdfDocument* self) { + return self->pageCount(); +} + +QSizeF* QPdfDocument_pagePointSize(const QPdfDocument* self, int page) { + return new QSizeF(self->pagePointSize(static_cast(page))); +} + +struct miqt_string QPdfDocument_pageLabel(QPdfDocument* self, int page) { + QString _ret = self->pageLabel(static_cast(page)); + // 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; +} + +QAbstractListModel* QPdfDocument_pageModel(QPdfDocument* self) { + return self->pageModel(); +} + +QImage* QPdfDocument_render(QPdfDocument* self, int page, QSize* imageSize) { + return new QImage(self->render(static_cast(page), *imageSize)); +} + +QPdfSelection* QPdfDocument_getSelection(QPdfDocument* self, int page, QPointF* start, QPointF* end) { + return new QPdfSelection(self->getSelection(static_cast(page), *start, *end)); +} + +QPdfSelection* QPdfDocument_getSelectionAtIndex(QPdfDocument* self, int page, int startIndex, int maxLength) { + return new QPdfSelection(self->getSelectionAtIndex(static_cast(page), static_cast(startIndex), static_cast(maxLength))); +} + +QPdfSelection* QPdfDocument_getAllText(QPdfDocument* self, int page) { + return new QPdfSelection(self->getAllText(static_cast(page))); +} + +void QPdfDocument_passwordChanged(QPdfDocument* self) { + self->passwordChanged(); +} + +void QPdfDocument_connect_passwordChanged(QPdfDocument* self, intptr_t slot) { + MiqtVirtualQPdfDocument::connect(self, static_cast(&QPdfDocument::passwordChanged), self, [=]() { + miqt_exec_callback_QPdfDocument_passwordChanged(slot); + }); +} + +void QPdfDocument_passwordRequired(QPdfDocument* self) { + self->passwordRequired(); +} + +void QPdfDocument_connect_passwordRequired(QPdfDocument* self, intptr_t slot) { + MiqtVirtualQPdfDocument::connect(self, static_cast(&QPdfDocument::passwordRequired), self, [=]() { + miqt_exec_callback_QPdfDocument_passwordRequired(slot); + }); +} + +void QPdfDocument_statusChanged(QPdfDocument* self, int status) { + self->statusChanged(static_cast(status)); +} + +void QPdfDocument_connect_statusChanged(QPdfDocument* self, intptr_t slot) { + MiqtVirtualQPdfDocument::connect(self, static_cast(&QPdfDocument::statusChanged), self, [=](QPdfDocument::Status status) { + QPdfDocument::Status status_ret = status; + int sigval1 = static_cast(status_ret); + miqt_exec_callback_QPdfDocument_statusChanged(slot, sigval1); + }); +} + +void QPdfDocument_pageCountChanged(QPdfDocument* self, int pageCount) { + self->pageCountChanged(static_cast(pageCount)); +} + +void QPdfDocument_connect_pageCountChanged(QPdfDocument* self, intptr_t slot) { + MiqtVirtualQPdfDocument::connect(self, static_cast(&QPdfDocument::pageCountChanged), self, [=](int pageCount) { + int sigval1 = pageCount; + miqt_exec_callback_QPdfDocument_pageCountChanged(slot, sigval1); + }); +} + +void QPdfDocument_pageModelChanged(QPdfDocument* self) { + self->pageModelChanged(); +} + +void QPdfDocument_connect_pageModelChanged(QPdfDocument* self, intptr_t slot) { + MiqtVirtualQPdfDocument::connect(self, static_cast(&QPdfDocument::pageModelChanged), self, [=]() { + miqt_exec_callback_QPdfDocument_pageModelChanged(slot); + }); +} + +struct miqt_string QPdfDocument_tr2(const char* s, const char* c) { + QString _ret = QPdfDocument::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 QPdfDocument_tr3(const char* s, const char* c, int n) { + QString _ret = QPdfDocument::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; +} + +QImage* QPdfDocument_render2(QPdfDocument* self, int page, QSize* imageSize, QPdfDocumentRenderOptions* options) { + return new QImage(self->render(static_cast(page), *imageSize, *options)); +} + +bool QPdfDocument_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QPdfDocument_virtualbase_event(void* self, QEvent* event) { + + return ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::event(event); + +} + +bool QPdfDocument_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QPdfDocument_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + + return ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::eventFilter(watched, event); + +} + +bool QPdfDocument_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QPdfDocument_virtualbase_timerEvent(void* self, QTimerEvent* event) { + + ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::timerEvent(event); + +} + +bool QPdfDocument_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QPdfDocument_virtualbase_childEvent(void* self, QChildEvent* event) { + + ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::childEvent(event); + +} + +bool QPdfDocument_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QPdfDocument_virtualbase_customEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::customEvent(event); + +} + +bool QPdfDocument_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QPdfDocument_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::connectNotify(*signal); + +} + +bool QPdfDocument_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QPdfDocument_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfDocument*)(self) )->QPdfDocument::disconnectNotify(*signal); + +} + +QObject* QPdfDocument_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return self_cast->sender(); + +} + +int QPdfDocument_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->senderSignalIndex(); + +} + +int QPdfDocument_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->receivers(signal); + +} + +bool QPdfDocument_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQPdfDocument* self_cast = dynamic_cast( (QPdfDocument*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->isSignalConnected(*signal); + +} + +void QPdfDocument_delete(QPdfDocument* self) { + delete self; +} + diff --git a/qt6/pdf/gen_qpdfdocument.go b/qt6/pdf/gen_qpdfdocument.go new file mode 100644 index 00000000..67c556ad --- /dev/null +++ b/qt6/pdf/gen_qpdfdocument.go @@ -0,0 +1,595 @@ +package pdf + +/* + +#include "gen_qpdfdocument.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QPdfDocument__Status int + +const ( + QPdfDocument__Status__Null QPdfDocument__Status = 0 + QPdfDocument__Status__Loading QPdfDocument__Status = 1 + QPdfDocument__Status__Ready QPdfDocument__Status = 2 + QPdfDocument__Status__Unloading QPdfDocument__Status = 3 + QPdfDocument__Status__Error QPdfDocument__Status = 4 +) + +type QPdfDocument__Error int + +const ( + QPdfDocument__None QPdfDocument__Error = 0 + QPdfDocument__Unknown QPdfDocument__Error = 1 + QPdfDocument__DataNotYetAvailable QPdfDocument__Error = 2 + QPdfDocument__FileNotFound QPdfDocument__Error = 3 + QPdfDocument__InvalidFileFormat QPdfDocument__Error = 4 + QPdfDocument__IncorrectPassword QPdfDocument__Error = 5 + QPdfDocument__UnsupportedSecurityScheme QPdfDocument__Error = 6 +) + +type QPdfDocument__MetaDataField int + +const ( + QPdfDocument__Title QPdfDocument__MetaDataField = 0 + QPdfDocument__Subject QPdfDocument__MetaDataField = 1 + QPdfDocument__Author QPdfDocument__MetaDataField = 2 + QPdfDocument__Keywords QPdfDocument__MetaDataField = 3 + QPdfDocument__Producer QPdfDocument__MetaDataField = 4 + QPdfDocument__Creator QPdfDocument__MetaDataField = 5 + QPdfDocument__CreationDate QPdfDocument__MetaDataField = 6 + QPdfDocument__ModificationDate QPdfDocument__MetaDataField = 7 +) + +type QPdfDocument__PageModelRole int + +const ( + QPdfDocument__Label QPdfDocument__PageModelRole = 256 + QPdfDocument__PointSize QPdfDocument__PageModelRole = 257 + QPdfDocument__NRoles QPdfDocument__PageModelRole = 258 +) + +type QPdfDocument struct { + h *C.QPdfDocument + *qt6.QObject +} + +func (this *QPdfDocument) cPointer() *C.QPdfDocument { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfDocument) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfDocument constructs the type using only CGO pointers. +func newQPdfDocument(h *C.QPdfDocument) *QPdfDocument { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QPdfDocument_virtbase(h, &outptr_QObject) + + return &QPdfDocument{h: h, + QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQPdfDocument constructs the type using only unsafe pointers. +func UnsafeNewQPdfDocument(h unsafe.Pointer) *QPdfDocument { + return newQPdfDocument((*C.QPdfDocument)(h)) +} + +// NewQPdfDocument constructs a new QPdfDocument object. +func NewQPdfDocument() *QPdfDocument { + + return newQPdfDocument(C.QPdfDocument_new()) +} + +// NewQPdfDocument2 constructs a new QPdfDocument object. +func NewQPdfDocument2(parent *qt6.QObject) *QPdfDocument { + + return newQPdfDocument(C.QPdfDocument_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QPdfDocument) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QPdfDocument_metaObject(this.h))) +} + +func (this *QPdfDocument) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QPdfDocument_metacast(this.h, param1_Cstring)) +} + +func QPdfDocument_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfDocument_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfDocument) Load(fileName string) QPdfDocument__Error { + fileName_ms := C.struct_miqt_string{} + fileName_ms.data = C.CString(fileName) + fileName_ms.len = C.size_t(len(fileName)) + defer C.free(unsafe.Pointer(fileName_ms.data)) + return (QPdfDocument__Error)(C.QPdfDocument_load(this.h, fileName_ms)) +} + +func (this *QPdfDocument) Status() QPdfDocument__Status { + return (QPdfDocument__Status)(C.QPdfDocument_status(this.h)) +} + +func (this *QPdfDocument) LoadWithDevice(device *qt6.QIODevice) { + C.QPdfDocument_loadWithDevice(this.h, (*C.QIODevice)(device.UnsafePointer())) +} + +func (this *QPdfDocument) SetPassword(password string) { + password_ms := C.struct_miqt_string{} + password_ms.data = C.CString(password) + password_ms.len = C.size_t(len(password)) + defer C.free(unsafe.Pointer(password_ms.data)) + C.QPdfDocument_setPassword(this.h, password_ms) +} + +func (this *QPdfDocument) Password() string { + var _ms C.struct_miqt_string = C.QPdfDocument_password(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfDocument) MetaData(field QPdfDocument__MetaDataField) *qt6.QVariant { + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QPdfDocument_metaData(this.h, (C.int)(field)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocument) Error() QPdfDocument__Error { + return (QPdfDocument__Error)(C.QPdfDocument_error(this.h)) +} + +func (this *QPdfDocument) Close() { + C.QPdfDocument_close(this.h) +} + +func (this *QPdfDocument) PageCount() int { + return (int)(C.QPdfDocument_pageCount(this.h)) +} + +func (this *QPdfDocument) PagePointSize(page int) *qt6.QSizeF { + _goptr := qt6.UnsafeNewQSizeF(unsafe.Pointer(C.QPdfDocument_pagePointSize(this.h, (C.int)(page)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocument) PageLabel(page int) string { + var _ms C.struct_miqt_string = C.QPdfDocument_pageLabel(this.h, (C.int)(page)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfDocument) PageModel() *qt6.QAbstractListModel { + return qt6.UnsafeNewQAbstractListModel(unsafe.Pointer(C.QPdfDocument_pageModel(this.h))) +} + +func (this *QPdfDocument) Render(page int, imageSize qt6.QSize) *qt6.QImage { + _goptr := qt6.UnsafeNewQImage(unsafe.Pointer(C.QPdfDocument_render(this.h, (C.int)(page), (*C.QSize)(imageSize.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocument) GetSelection(page int, start qt6.QPointF, end qt6.QPointF) *QPdfSelection { + _goptr := newQPdfSelection(C.QPdfDocument_getSelection(this.h, (C.int)(page), (*C.QPointF)(start.UnsafePointer()), (*C.QPointF)(end.UnsafePointer()))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocument) GetSelectionAtIndex(page int, startIndex int, maxLength int) *QPdfSelection { + _goptr := newQPdfSelection(C.QPdfDocument_getSelectionAtIndex(this.h, (C.int)(page), (C.int)(startIndex), (C.int)(maxLength))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocument) GetAllText(page int) *QPdfSelection { + _goptr := newQPdfSelection(C.QPdfDocument_getAllText(this.h, (C.int)(page))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocument) PasswordChanged() { + C.QPdfDocument_passwordChanged(this.h) +} +func (this *QPdfDocument) OnPasswordChanged(slot func()) { + C.QPdfDocument_connect_passwordChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfDocument_passwordChanged +func miqt_exec_callback_QPdfDocument_passwordChanged(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *QPdfDocument) PasswordRequired() { + C.QPdfDocument_passwordRequired(this.h) +} +func (this *QPdfDocument) OnPasswordRequired(slot func()) { + C.QPdfDocument_connect_passwordRequired(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfDocument_passwordRequired +func miqt_exec_callback_QPdfDocument_passwordRequired(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *QPdfDocument) StatusChanged(status QPdfDocument__Status) { + C.QPdfDocument_statusChanged(this.h, (C.int)(status)) +} +func (this *QPdfDocument) OnStatusChanged(slot func(status QPdfDocument__Status)) { + C.QPdfDocument_connect_statusChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfDocument_statusChanged +func miqt_exec_callback_QPdfDocument_statusChanged(cb C.intptr_t, status C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(status QPdfDocument__Status)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (QPdfDocument__Status)(status) + + gofunc(slotval1) +} + +func (this *QPdfDocument) PageCountChanged(pageCount int) { + C.QPdfDocument_pageCountChanged(this.h, (C.int)(pageCount)) +} +func (this *QPdfDocument) OnPageCountChanged(slot func(pageCount int)) { + C.QPdfDocument_connect_pageCountChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfDocument_pageCountChanged +func miqt_exec_callback_QPdfDocument_pageCountChanged(cb C.intptr_t, pageCount C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(pageCount int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(pageCount) + + gofunc(slotval1) +} + +func (this *QPdfDocument) PageModelChanged() { + C.QPdfDocument_pageModelChanged(this.h) +} +func (this *QPdfDocument) OnPageModelChanged(slot func()) { + C.QPdfDocument_connect_pageModelChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfDocument_pageModelChanged +func miqt_exec_callback_QPdfDocument_pageModelChanged(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func QPdfDocument_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfDocument_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfDocument_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfDocument_tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfDocument) Render2(page int, imageSize qt6.QSize, options QPdfDocumentRenderOptions) *qt6.QImage { + _goptr := qt6.UnsafeNewQImage(unsafe.Pointer(C.QPdfDocument_render2(this.h, (C.int)(page), (*C.QSize)(imageSize.UnsafePointer()), options.cPointer()))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +// Sender can only be called from a QPdfDocument that was directly constructed. +func (this *QPdfDocument) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QPdfDocument_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// SenderSignalIndex can only be called from a QPdfDocument that was directly constructed. +func (this *QPdfDocument) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfDocument_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Receivers can only be called from a QPdfDocument that was directly constructed. +func (this *QPdfDocument) Receivers(signal string) int { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfDocument_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// IsSignalConnected can only be called from a QPdfDocument that was directly constructed. +func (this *QPdfDocument) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfDocument_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +func (this *QPdfDocument) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QPdfDocument_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfDocument) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QPdfDocument_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_event +func miqt_exec_callback_QPdfDocument_event(self *C.QPdfDocument, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfDocument{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfDocument) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QPdfDocument_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfDocument) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QPdfDocument_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_eventFilter +func miqt_exec_callback_QPdfDocument_eventFilter(self *C.QPdfDocument, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfDocument{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfDocument) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QPdfDocument_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QPdfDocument) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QPdfDocument_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_timerEvent +func miqt_exec_callback_QPdfDocument_timerEvent(self *C.QPdfDocument, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QPdfDocument{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QPdfDocument) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QPdfDocument_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QPdfDocument) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QPdfDocument_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_childEvent +func miqt_exec_callback_QPdfDocument_childEvent(self *C.QPdfDocument, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QPdfDocument{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QPdfDocument) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QPdfDocument_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfDocument) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QPdfDocument_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_customEvent +func miqt_exec_callback_QPdfDocument_customEvent(self *C.QPdfDocument, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent), event *qt6.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfDocument{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QPdfDocument) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QPdfDocument_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfDocument) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QPdfDocument_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_connectNotify +func miqt_exec_callback_QPdfDocument_connectNotify(self *C.QPdfDocument, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfDocument{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QPdfDocument) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QPdfDocument_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfDocument) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QPdfDocument_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfDocument_disconnectNotify +func miqt_exec_callback_QPdfDocument_disconnectNotify(self *C.QPdfDocument, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfDocument{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QPdfDocument) Delete() { + C.QPdfDocument_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfDocument) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfDocument) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/pdf/gen_qpdfdocument.h b/qt6/pdf/gen_qpdfdocument.h new file mode 100644 index 00000000..d268d373 --- /dev/null +++ b/qt6/pdf/gen_qpdfdocument.h @@ -0,0 +1,112 @@ +#pragma once +#ifndef MIQT_QT6_PDF_GEN_QPDFDOCUMENT_H +#define MIQT_QT6_PDF_GEN_QPDFDOCUMENT_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractListModel; +class QChildEvent; +class QEvent; +class QIODevice; +class QImage; +class QMetaMethod; +class QMetaObject; +class QObject; +class QPdfDocument; +class QPdfDocumentRenderOptions; +class QPdfSelection; +class QPointF; +class QSize; +class QSizeF; +class QTimerEvent; +class QVariant; +#else +typedef struct QAbstractListModel QAbstractListModel; +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QIODevice QIODevice; +typedef struct QImage QImage; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QPdfDocument QPdfDocument; +typedef struct QPdfDocumentRenderOptions QPdfDocumentRenderOptions; +typedef struct QPdfSelection QPdfSelection; +typedef struct QPointF QPointF; +typedef struct QSize QSize; +typedef struct QSizeF QSizeF; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +#endif + +QPdfDocument* QPdfDocument_new(); +QPdfDocument* QPdfDocument_new2(QObject* parent); +void QPdfDocument_virtbase(QPdfDocument* src, QObject** outptr_QObject); +QMetaObject* QPdfDocument_metaObject(const QPdfDocument* self); +void* QPdfDocument_metacast(QPdfDocument* self, const char* param1); +struct miqt_string QPdfDocument_tr(const char* s); +int QPdfDocument_load(QPdfDocument* self, struct miqt_string fileName); +int QPdfDocument_status(const QPdfDocument* self); +void QPdfDocument_loadWithDevice(QPdfDocument* self, QIODevice* device); +void QPdfDocument_setPassword(QPdfDocument* self, struct miqt_string password); +struct miqt_string QPdfDocument_password(const QPdfDocument* self); +QVariant* QPdfDocument_metaData(const QPdfDocument* self, int field); +int QPdfDocument_error(const QPdfDocument* self); +void QPdfDocument_close(QPdfDocument* self); +int QPdfDocument_pageCount(const QPdfDocument* self); +QSizeF* QPdfDocument_pagePointSize(const QPdfDocument* self, int page); +struct miqt_string QPdfDocument_pageLabel(QPdfDocument* self, int page); +QAbstractListModel* QPdfDocument_pageModel(QPdfDocument* self); +QImage* QPdfDocument_render(QPdfDocument* self, int page, QSize* imageSize); +QPdfSelection* QPdfDocument_getSelection(QPdfDocument* self, int page, QPointF* start, QPointF* end); +QPdfSelection* QPdfDocument_getSelectionAtIndex(QPdfDocument* self, int page, int startIndex, int maxLength); +QPdfSelection* QPdfDocument_getAllText(QPdfDocument* self, int page); +void QPdfDocument_passwordChanged(QPdfDocument* self); +void QPdfDocument_connect_passwordChanged(QPdfDocument* self, intptr_t slot); +void QPdfDocument_passwordRequired(QPdfDocument* self); +void QPdfDocument_connect_passwordRequired(QPdfDocument* self, intptr_t slot); +void QPdfDocument_statusChanged(QPdfDocument* self, int status); +void QPdfDocument_connect_statusChanged(QPdfDocument* self, intptr_t slot); +void QPdfDocument_pageCountChanged(QPdfDocument* self, int pageCount); +void QPdfDocument_connect_pageCountChanged(QPdfDocument* self, intptr_t slot); +void QPdfDocument_pageModelChanged(QPdfDocument* self); +void QPdfDocument_connect_pageModelChanged(QPdfDocument* self, intptr_t slot); +struct miqt_string QPdfDocument_tr2(const char* s, const char* c); +struct miqt_string QPdfDocument_tr3(const char* s, const char* c, int n); +QImage* QPdfDocument_render2(QPdfDocument* self, int page, QSize* imageSize, QPdfDocumentRenderOptions* options); +bool QPdfDocument_override_virtual_event(void* self, intptr_t slot); +bool QPdfDocument_virtualbase_event(void* self, QEvent* event); +bool QPdfDocument_override_virtual_eventFilter(void* self, intptr_t slot); +bool QPdfDocument_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QPdfDocument_override_virtual_timerEvent(void* self, intptr_t slot); +void QPdfDocument_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QPdfDocument_override_virtual_childEvent(void* self, intptr_t slot); +void QPdfDocument_virtualbase_childEvent(void* self, QChildEvent* event); +bool QPdfDocument_override_virtual_customEvent(void* self, intptr_t slot); +void QPdfDocument_virtualbase_customEvent(void* self, QEvent* event); +bool QPdfDocument_override_virtual_connectNotify(void* self, intptr_t slot); +void QPdfDocument_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QPdfDocument_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QPdfDocument_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); +QObject* QPdfDocument_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QPdfDocument_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QPdfDocument_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QPdfDocument_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +void QPdfDocument_delete(QPdfDocument* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/pdf/gen_qpdfdocumentrenderoptions.cpp b/qt6/pdf/gen_qpdfdocumentrenderoptions.cpp new file mode 100644 index 00000000..248b7ba7 --- /dev/null +++ b/qt6/pdf/gen_qpdfdocumentrenderoptions.cpp @@ -0,0 +1,60 @@ +#include +#include +#include +#include +#include "gen_qpdfdocumentrenderoptions.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +QPdfDocumentRenderOptions* QPdfDocumentRenderOptions_new() { + return new QPdfDocumentRenderOptions(); +} + +QPdfDocumentRenderOptions* QPdfDocumentRenderOptions_new2(QPdfDocumentRenderOptions* param1) { + return new QPdfDocumentRenderOptions(*param1); +} + +int QPdfDocumentRenderOptions_rotation(const QPdfDocumentRenderOptions* self) { + QPdfDocumentRenderOptions::Rotation _ret = self->rotation(); + return static_cast(_ret); +} + +void QPdfDocumentRenderOptions_setRotation(QPdfDocumentRenderOptions* self, int r) { + self->setRotation(static_cast(r)); +} + +int QPdfDocumentRenderOptions_renderFlags(const QPdfDocumentRenderOptions* self) { + QPdfDocumentRenderOptions::RenderFlags _ret = self->renderFlags(); + return static_cast(_ret); +} + +void QPdfDocumentRenderOptions_setRenderFlags(QPdfDocumentRenderOptions* self, int r) { + self->setRenderFlags(static_cast(r)); +} + +QRect* QPdfDocumentRenderOptions_scaledClipRect(const QPdfDocumentRenderOptions* self) { + return new QRect(self->scaledClipRect()); +} + +void QPdfDocumentRenderOptions_setScaledClipRect(QPdfDocumentRenderOptions* self, QRect* r) { + self->setScaledClipRect(*r); +} + +QSize* QPdfDocumentRenderOptions_scaledSize(const QPdfDocumentRenderOptions* self) { + return new QSize(self->scaledSize()); +} + +void QPdfDocumentRenderOptions_setScaledSize(QPdfDocumentRenderOptions* self, QSize* s) { + self->setScaledSize(*s); +} + +void QPdfDocumentRenderOptions_delete(QPdfDocumentRenderOptions* self) { + delete self; +} + diff --git a/qt6/pdf/gen_qpdfdocumentrenderoptions.go b/qt6/pdf/gen_qpdfdocumentrenderoptions.go new file mode 100644 index 00000000..166ef9bc --- /dev/null +++ b/qt6/pdf/gen_qpdfdocumentrenderoptions.go @@ -0,0 +1,131 @@ +package pdf + +/* + +#include "gen_qpdfdocumentrenderoptions.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "unsafe" +) + +type QPdfDocumentRenderOptions__Rotation int + +const ( + QPdfDocumentRenderOptions__Rotation__None QPdfDocumentRenderOptions__Rotation = 0 + QPdfDocumentRenderOptions__Rotation__Clockwise90 QPdfDocumentRenderOptions__Rotation = 1 + QPdfDocumentRenderOptions__Rotation__Clockwise180 QPdfDocumentRenderOptions__Rotation = 2 + QPdfDocumentRenderOptions__Rotation__Clockwise270 QPdfDocumentRenderOptions__Rotation = 3 +) + +type QPdfDocumentRenderOptions__RenderFlag int + +const ( + QPdfDocumentRenderOptions__RenderFlag__None QPdfDocumentRenderOptions__RenderFlag = 0 + QPdfDocumentRenderOptions__RenderFlag__Annotations QPdfDocumentRenderOptions__RenderFlag = 1 + QPdfDocumentRenderOptions__RenderFlag__OptimizedForLcd QPdfDocumentRenderOptions__RenderFlag = 2 + QPdfDocumentRenderOptions__RenderFlag__Grayscale QPdfDocumentRenderOptions__RenderFlag = 4 + QPdfDocumentRenderOptions__RenderFlag__ForceHalftone QPdfDocumentRenderOptions__RenderFlag = 8 + QPdfDocumentRenderOptions__RenderFlag__TextAliased QPdfDocumentRenderOptions__RenderFlag = 16 + QPdfDocumentRenderOptions__RenderFlag__ImageAliased QPdfDocumentRenderOptions__RenderFlag = 32 + QPdfDocumentRenderOptions__RenderFlag__PathAliased QPdfDocumentRenderOptions__RenderFlag = 64 +) + +type QPdfDocumentRenderOptions struct { + h *C.QPdfDocumentRenderOptions +} + +func (this *QPdfDocumentRenderOptions) cPointer() *C.QPdfDocumentRenderOptions { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfDocumentRenderOptions) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfDocumentRenderOptions constructs the type using only CGO pointers. +func newQPdfDocumentRenderOptions(h *C.QPdfDocumentRenderOptions) *QPdfDocumentRenderOptions { + if h == nil { + return nil + } + + return &QPdfDocumentRenderOptions{h: h} +} + +// UnsafeNewQPdfDocumentRenderOptions constructs the type using only unsafe pointers. +func UnsafeNewQPdfDocumentRenderOptions(h unsafe.Pointer) *QPdfDocumentRenderOptions { + return newQPdfDocumentRenderOptions((*C.QPdfDocumentRenderOptions)(h)) +} + +// NewQPdfDocumentRenderOptions constructs a new QPdfDocumentRenderOptions object. +func NewQPdfDocumentRenderOptions() *QPdfDocumentRenderOptions { + + return newQPdfDocumentRenderOptions(C.QPdfDocumentRenderOptions_new()) +} + +// NewQPdfDocumentRenderOptions2 constructs a new QPdfDocumentRenderOptions object. +func NewQPdfDocumentRenderOptions2(param1 *QPdfDocumentRenderOptions) *QPdfDocumentRenderOptions { + + return newQPdfDocumentRenderOptions(C.QPdfDocumentRenderOptions_new2(param1.cPointer())) +} + +func (this *QPdfDocumentRenderOptions) Rotation() QPdfDocumentRenderOptions__Rotation { + return (QPdfDocumentRenderOptions__Rotation)(C.QPdfDocumentRenderOptions_rotation(this.h)) +} + +func (this *QPdfDocumentRenderOptions) SetRotation(r QPdfDocumentRenderOptions__Rotation) { + C.QPdfDocumentRenderOptions_setRotation(this.h, (C.int)(r)) +} + +func (this *QPdfDocumentRenderOptions) RenderFlags() QPdfDocumentRenderOptions__RenderFlag { + return (QPdfDocumentRenderOptions__RenderFlag)(C.QPdfDocumentRenderOptions_renderFlags(this.h)) +} + +func (this *QPdfDocumentRenderOptions) SetRenderFlags(r QPdfDocumentRenderOptions__RenderFlag) { + C.QPdfDocumentRenderOptions_setRenderFlags(this.h, (C.int)(r)) +} + +func (this *QPdfDocumentRenderOptions) ScaledClipRect() *qt6.QRect { + _goptr := qt6.UnsafeNewQRect(unsafe.Pointer(C.QPdfDocumentRenderOptions_scaledClipRect(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocumentRenderOptions) SetScaledClipRect(r *qt6.QRect) { + C.QPdfDocumentRenderOptions_setScaledClipRect(this.h, (*C.QRect)(r.UnsafePointer())) +} + +func (this *QPdfDocumentRenderOptions) ScaledSize() *qt6.QSize { + _goptr := qt6.UnsafeNewQSize(unsafe.Pointer(C.QPdfDocumentRenderOptions_scaledSize(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfDocumentRenderOptions) SetScaledSize(s *qt6.QSize) { + C.QPdfDocumentRenderOptions_setScaledSize(this.h, (*C.QSize)(s.UnsafePointer())) +} + +// Delete this object from C++ memory. +func (this *QPdfDocumentRenderOptions) Delete() { + C.QPdfDocumentRenderOptions_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfDocumentRenderOptions) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfDocumentRenderOptions) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/pdf/gen_qpdfdocumentrenderoptions.h b/qt6/pdf/gen_qpdfdocumentrenderoptions.h new file mode 100644 index 00000000..e38a3f39 --- /dev/null +++ b/qt6/pdf/gen_qpdfdocumentrenderoptions.h @@ -0,0 +1,43 @@ +#pragma once +#ifndef MIQT_QT6_PDF_GEN_QPDFDOCUMENTRENDEROPTIONS_H +#define MIQT_QT6_PDF_GEN_QPDFDOCUMENTRENDEROPTIONS_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QPdfDocumentRenderOptions; +class QRect; +class QSize; +#else +typedef struct QPdfDocumentRenderOptions QPdfDocumentRenderOptions; +typedef struct QRect QRect; +typedef struct QSize QSize; +#endif + +QPdfDocumentRenderOptions* QPdfDocumentRenderOptions_new(); +QPdfDocumentRenderOptions* QPdfDocumentRenderOptions_new2(QPdfDocumentRenderOptions* param1); +int QPdfDocumentRenderOptions_rotation(const QPdfDocumentRenderOptions* self); +void QPdfDocumentRenderOptions_setRotation(QPdfDocumentRenderOptions* self, int r); +int QPdfDocumentRenderOptions_renderFlags(const QPdfDocumentRenderOptions* self); +void QPdfDocumentRenderOptions_setRenderFlags(QPdfDocumentRenderOptions* self, int r); +QRect* QPdfDocumentRenderOptions_scaledClipRect(const QPdfDocumentRenderOptions* self); +void QPdfDocumentRenderOptions_setScaledClipRect(QPdfDocumentRenderOptions* self, QRect* r); +QSize* QPdfDocumentRenderOptions_scaledSize(const QPdfDocumentRenderOptions* self); +void QPdfDocumentRenderOptions_setScaledSize(QPdfDocumentRenderOptions* self, QSize* s); +void QPdfDocumentRenderOptions_delete(QPdfDocumentRenderOptions* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/pdf/gen_qpdflink.cpp b/qt6/pdf/gen_qpdflink.cpp new file mode 100644 index 00000000..0462f671 --- /dev/null +++ b/qt6/pdf/gen_qpdflink.cpp @@ -0,0 +1,114 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qpdflink.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +QPdfLink* QPdfLink_new() { + return new QPdfLink(); +} + +QPdfLink* QPdfLink_new2(QPdfLink* other) { + return new QPdfLink(*other); +} + +void QPdfLink_operatorAssign(QPdfLink* self, QPdfLink* other) { + self->operator=(*other); +} + +void QPdfLink_swap(QPdfLink* self, QPdfLink* other) { + self->swap(*other); +} + +bool QPdfLink_isValid(const QPdfLink* self) { + return self->isValid(); +} + +int QPdfLink_page(const QPdfLink* self) { + return self->page(); +} + +QPointF* QPdfLink_location(const QPdfLink* self) { + return new QPointF(self->location()); +} + +double QPdfLink_zoom(const QPdfLink* self) { + qreal _ret = self->zoom(); + return static_cast(_ret); +} + +QUrl* QPdfLink_url(const QPdfLink* self) { + return new QUrl(self->url()); +} + +struct miqt_string QPdfLink_contextBefore(const QPdfLink* self) { + QString _ret = self->contextBefore(); + // 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 QPdfLink_contextAfter(const QPdfLink* self) { + QString _ret = self->contextAfter(); + // 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_array /* of QRectF* */ QPdfLink_rectangles(const QPdfLink* self) { + QList _ret = self->rectangles(); + // Convert QList<> from C++ memory to manually-managed C memory + QRectF** _arr = static_cast(malloc(sizeof(QRectF*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QRectF(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +struct miqt_string QPdfLink_toString(const QPdfLink* self) { + QString _ret = self->toString(); + // 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 QPdfLink_copyToClipboard(const QPdfLink* self) { + self->copyToClipboard(); +} + +void QPdfLink_copyToClipboardWithMode(const QPdfLink* self, int mode) { + self->copyToClipboard(static_cast(mode)); +} + +void QPdfLink_delete(QPdfLink* self) { + delete self; +} + diff --git a/qt6/pdf/gen_qpdflink.go b/qt6/pdf/gen_qpdflink.go new file mode 100644 index 00000000..81638c8f --- /dev/null +++ b/qt6/pdf/gen_qpdflink.go @@ -0,0 +1,146 @@ +package pdf + +/* + +#include "gen_qpdflink.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "unsafe" +) + +type QPdfLink struct { + h *C.QPdfLink +} + +func (this *QPdfLink) cPointer() *C.QPdfLink { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfLink) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfLink constructs the type using only CGO pointers. +func newQPdfLink(h *C.QPdfLink) *QPdfLink { + if h == nil { + return nil + } + + return &QPdfLink{h: h} +} + +// UnsafeNewQPdfLink constructs the type using only unsafe pointers. +func UnsafeNewQPdfLink(h unsafe.Pointer) *QPdfLink { + return newQPdfLink((*C.QPdfLink)(h)) +} + +// NewQPdfLink constructs a new QPdfLink object. +func NewQPdfLink() *QPdfLink { + + return newQPdfLink(C.QPdfLink_new()) +} + +// NewQPdfLink2 constructs a new QPdfLink object. +func NewQPdfLink2(other *QPdfLink) *QPdfLink { + + return newQPdfLink(C.QPdfLink_new2(other.cPointer())) +} + +func (this *QPdfLink) OperatorAssign(other *QPdfLink) { + C.QPdfLink_operatorAssign(this.h, other.cPointer()) +} + +func (this *QPdfLink) Swap(other *QPdfLink) { + C.QPdfLink_swap(this.h, other.cPointer()) +} + +func (this *QPdfLink) IsValid() bool { + return (bool)(C.QPdfLink_isValid(this.h)) +} + +func (this *QPdfLink) Page() int { + return (int)(C.QPdfLink_page(this.h)) +} + +func (this *QPdfLink) Location() *qt6.QPointF { + _goptr := qt6.UnsafeNewQPointF(unsafe.Pointer(C.QPdfLink_location(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfLink) Zoom() float64 { + return (float64)(C.QPdfLink_zoom(this.h)) +} + +func (this *QPdfLink) Url() *qt6.QUrl { + _goptr := qt6.UnsafeNewQUrl(unsafe.Pointer(C.QPdfLink_url(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfLink) ContextBefore() string { + var _ms C.struct_miqt_string = C.QPdfLink_contextBefore(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfLink) ContextAfter() string { + var _ms C.struct_miqt_string = C.QPdfLink_contextAfter(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfLink) Rectangles() []qt6.QRectF { + var _ma C.struct_miqt_array = C.QPdfLink_rectangles(this.h) + _ret := make([]qt6.QRectF, int(_ma.len)) + _outCast := (*[0xffff]*C.QRectF)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt6.UnsafeNewQRectF(unsafe.Pointer(_outCast[i])) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret +} + +func (this *QPdfLink) ToString() string { + var _ms C.struct_miqt_string = C.QPdfLink_toString(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfLink) CopyToClipboard() { + C.QPdfLink_copyToClipboard(this.h) +} + +func (this *QPdfLink) CopyToClipboardWithMode(mode qt6.QClipboard__Mode) { + C.QPdfLink_copyToClipboardWithMode(this.h, (C.int)(mode)) +} + +// Delete this object from C++ memory. +func (this *QPdfLink) Delete() { + C.QPdfLink_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfLink) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfLink) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/pdf/gen_qpdflink.h b/qt6/pdf/gen_qpdflink.h new file mode 100644 index 00000000..87c09d4a --- /dev/null +++ b/qt6/pdf/gen_qpdflink.h @@ -0,0 +1,50 @@ +#pragma once +#ifndef MIQT_QT6_PDF_GEN_QPDFLINK_H +#define MIQT_QT6_PDF_GEN_QPDFLINK_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QPdfLink; +class QPointF; +class QRectF; +class QUrl; +#else +typedef struct QPdfLink QPdfLink; +typedef struct QPointF QPointF; +typedef struct QRectF QRectF; +typedef struct QUrl QUrl; +#endif + +QPdfLink* QPdfLink_new(); +QPdfLink* QPdfLink_new2(QPdfLink* other); +void QPdfLink_operatorAssign(QPdfLink* self, QPdfLink* other); +void QPdfLink_swap(QPdfLink* self, QPdfLink* other); +bool QPdfLink_isValid(const QPdfLink* self); +int QPdfLink_page(const QPdfLink* self); +QPointF* QPdfLink_location(const QPdfLink* self); +double QPdfLink_zoom(const QPdfLink* self); +QUrl* QPdfLink_url(const QPdfLink* self); +struct miqt_string QPdfLink_contextBefore(const QPdfLink* self); +struct miqt_string QPdfLink_contextAfter(const QPdfLink* self); +struct miqt_array /* of QRectF* */ QPdfLink_rectangles(const QPdfLink* self); +struct miqt_string QPdfLink_toString(const QPdfLink* self); +void QPdfLink_copyToClipboard(const QPdfLink* self); +void QPdfLink_copyToClipboardWithMode(const QPdfLink* self, int mode); +void QPdfLink_delete(QPdfLink* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/pdf/gen_qpdfpagenavigator.cpp b/qt6/pdf/gen_qpdfpagenavigator.cpp new file mode 100644 index 00000000..6371c56b --- /dev/null +++ b/qt6/pdf/gen_qpdfpagenavigator.cpp @@ -0,0 +1,538 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qpdfpagenavigator.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QPdfPageNavigator_currentPageChanged(intptr_t, int); +void miqt_exec_callback_QPdfPageNavigator_currentLocationChanged(intptr_t, QPointF*); +void miqt_exec_callback_QPdfPageNavigator_currentZoomChanged(intptr_t, double); +void miqt_exec_callback_QPdfPageNavigator_backAvailableChanged(intptr_t, bool); +void miqt_exec_callback_QPdfPageNavigator_forwardAvailableChanged(intptr_t, bool); +void miqt_exec_callback_QPdfPageNavigator_jumped(intptr_t, QPdfLink*); +bool miqt_exec_callback_QPdfPageNavigator_event(QPdfPageNavigator*, intptr_t, QEvent*); +bool miqt_exec_callback_QPdfPageNavigator_eventFilter(QPdfPageNavigator*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QPdfPageNavigator_timerEvent(QPdfPageNavigator*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QPdfPageNavigator_childEvent(QPdfPageNavigator*, intptr_t, QChildEvent*); +void miqt_exec_callback_QPdfPageNavigator_customEvent(QPdfPageNavigator*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfPageNavigator_connectNotify(QPdfPageNavigator*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QPdfPageNavigator_disconnectNotify(QPdfPageNavigator*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQPdfPageNavigator final : public QPdfPageNavigator { +public: + + MiqtVirtualQPdfPageNavigator(): QPdfPageNavigator() {}; + MiqtVirtualQPdfPageNavigator(QObject* parent): QPdfPageNavigator(parent) {}; + + virtual ~MiqtVirtualQPdfPageNavigator() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QPdfPageNavigator::event(event); + } + + QEvent* sigval1 = event; + + bool callback_return_value = miqt_exec_callback_QPdfPageNavigator_event(this, handle__event, sigval1); + + return callback_return_value; + } + + friend bool QPdfPageNavigator_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QPdfPageNavigator::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + + bool callback_return_value = miqt_exec_callback_QPdfPageNavigator_eventFilter(this, handle__eventFilter, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfPageNavigator_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__timerEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void timerEvent(QTimerEvent* event) override { + if (handle__timerEvent == 0) { + QPdfPageNavigator::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + + miqt_exec_callback_QPdfPageNavigator_timerEvent(this, handle__timerEvent, sigval1); + + + } + + friend void QPdfPageNavigator_virtualbase_timerEvent(void* self, QTimerEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__childEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void childEvent(QChildEvent* event) override { + if (handle__childEvent == 0) { + QPdfPageNavigator::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + + miqt_exec_callback_QPdfPageNavigator_childEvent(this, handle__childEvent, sigval1); + + + } + + friend void QPdfPageNavigator_virtualbase_childEvent(void* self, QChildEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__customEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void customEvent(QEvent* event) override { + if (handle__customEvent == 0) { + QPdfPageNavigator::customEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfPageNavigator_customEvent(this, handle__customEvent, sigval1); + + + } + + friend void QPdfPageNavigator_virtualbase_customEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__connectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void connectNotify(const QMetaMethod& signal) override { + if (handle__connectNotify == 0) { + QPdfPageNavigator::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfPageNavigator_connectNotify(this, handle__connectNotify, sigval1); + + + } + + friend void QPdfPageNavigator_virtualbase_connectNotify(void* self, QMetaMethod* signal); + + // cgo.Handle value for overwritten implementation + intptr_t handle__disconnectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void disconnectNotify(const QMetaMethod& signal) override { + if (handle__disconnectNotify == 0) { + QPdfPageNavigator::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfPageNavigator_disconnectNotify(this, handle__disconnectNotify, sigval1); + + + } + + friend void QPdfPageNavigator_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QPdfLink* QPdfPageNavigator_protectedbase_currentLink(bool* _dynamic_cast_ok, const void* self); + friend QObject* QPdfPageNavigator_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QPdfPageNavigator_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QPdfPageNavigator_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QPdfPageNavigator_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QPdfPageNavigator* QPdfPageNavigator_new() { + return new MiqtVirtualQPdfPageNavigator(); +} + +QPdfPageNavigator* QPdfPageNavigator_new2(QObject* parent) { + return new MiqtVirtualQPdfPageNavigator(parent); +} + +void QPdfPageNavigator_virtbase(QPdfPageNavigator* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QPdfPageNavigator_metaObject(const QPdfPageNavigator* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QPdfPageNavigator_metacast(QPdfPageNavigator* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QPdfPageNavigator_tr(const char* s) { + QString _ret = QPdfPageNavigator::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; +} + +int QPdfPageNavigator_currentPage(const QPdfPageNavigator* self) { + return self->currentPage(); +} + +QPointF* QPdfPageNavigator_currentLocation(const QPdfPageNavigator* self) { + return new QPointF(self->currentLocation()); +} + +double QPdfPageNavigator_currentZoom(const QPdfPageNavigator* self) { + qreal _ret = self->currentZoom(); + return static_cast(_ret); +} + +bool QPdfPageNavigator_backAvailable(const QPdfPageNavigator* self) { + return self->backAvailable(); +} + +bool QPdfPageNavigator_forwardAvailable(const QPdfPageNavigator* self) { + return self->forwardAvailable(); +} + +void QPdfPageNavigator_clear(QPdfPageNavigator* self) { + self->clear(); +} + +void QPdfPageNavigator_jump(QPdfPageNavigator* self, QPdfLink* destination) { + self->jump(*destination); +} + +void QPdfPageNavigator_jump2(QPdfPageNavigator* self, int page, QPointF* location) { + self->jump(static_cast(page), *location); +} + +void QPdfPageNavigator_update(QPdfPageNavigator* self, int page, QPointF* location, double zoom) { + self->update(static_cast(page), *location, static_cast(zoom)); +} + +void QPdfPageNavigator_forward(QPdfPageNavigator* self) { + self->forward(); +} + +void QPdfPageNavigator_back(QPdfPageNavigator* self) { + self->back(); +} + +void QPdfPageNavigator_currentPageChanged(QPdfPageNavigator* self, int page) { + self->currentPageChanged(static_cast(page)); +} + +void QPdfPageNavigator_connect_currentPageChanged(QPdfPageNavigator* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator::connect(self, static_cast(&QPdfPageNavigator::currentPageChanged), self, [=](int page) { + int sigval1 = page; + miqt_exec_callback_QPdfPageNavigator_currentPageChanged(slot, sigval1); + }); +} + +void QPdfPageNavigator_currentLocationChanged(QPdfPageNavigator* self, QPointF* location) { + self->currentLocationChanged(*location); +} + +void QPdfPageNavigator_connect_currentLocationChanged(QPdfPageNavigator* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator::connect(self, static_cast(&QPdfPageNavigator::currentLocationChanged), self, [=](QPointF location) { + QPointF* sigval1 = new QPointF(location); + miqt_exec_callback_QPdfPageNavigator_currentLocationChanged(slot, sigval1); + }); +} + +void QPdfPageNavigator_currentZoomChanged(QPdfPageNavigator* self, double zoom) { + self->currentZoomChanged(static_cast(zoom)); +} + +void QPdfPageNavigator_connect_currentZoomChanged(QPdfPageNavigator* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator::connect(self, static_cast(&QPdfPageNavigator::currentZoomChanged), self, [=](qreal zoom) { + qreal zoom_ret = zoom; + double sigval1 = static_cast(zoom_ret); + miqt_exec_callback_QPdfPageNavigator_currentZoomChanged(slot, sigval1); + }); +} + +void QPdfPageNavigator_backAvailableChanged(QPdfPageNavigator* self, bool available) { + self->backAvailableChanged(available); +} + +void QPdfPageNavigator_connect_backAvailableChanged(QPdfPageNavigator* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator::connect(self, static_cast(&QPdfPageNavigator::backAvailableChanged), self, [=](bool available) { + bool sigval1 = available; + miqt_exec_callback_QPdfPageNavigator_backAvailableChanged(slot, sigval1); + }); +} + +void QPdfPageNavigator_forwardAvailableChanged(QPdfPageNavigator* self, bool available) { + self->forwardAvailableChanged(available); +} + +void QPdfPageNavigator_connect_forwardAvailableChanged(QPdfPageNavigator* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator::connect(self, static_cast(&QPdfPageNavigator::forwardAvailableChanged), self, [=](bool available) { + bool sigval1 = available; + miqt_exec_callback_QPdfPageNavigator_forwardAvailableChanged(slot, sigval1); + }); +} + +void QPdfPageNavigator_jumped(QPdfPageNavigator* self, QPdfLink* current) { + self->jumped(*current); +} + +void QPdfPageNavigator_connect_jumped(QPdfPageNavigator* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator::connect(self, static_cast(&QPdfPageNavigator::jumped), self, [=](QPdfLink current) { + QPdfLink* sigval1 = new QPdfLink(current); + miqt_exec_callback_QPdfPageNavigator_jumped(slot, sigval1); + }); +} + +struct miqt_string QPdfPageNavigator_tr2(const char* s, const char* c) { + QString _ret = QPdfPageNavigator::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 QPdfPageNavigator_tr3(const char* s, const char* c, int n) { + QString _ret = QPdfPageNavigator::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; +} + +void QPdfPageNavigator_jump3(QPdfPageNavigator* self, int page, QPointF* location, double zoom) { + self->jump(static_cast(page), *location, static_cast(zoom)); +} + +bool QPdfPageNavigator_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator* self_cast = dynamic_cast( (QPdfPageNavigator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QPdfPageNavigator_virtualbase_event(void* self, QEvent* event) { + + return ( (MiqtVirtualQPdfPageNavigator*)(self) )->QPdfPageNavigator::event(event); + +} + +bool QPdfPageNavigator_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator* self_cast = dynamic_cast( (QPdfPageNavigator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QPdfPageNavigator_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + + return ( (MiqtVirtualQPdfPageNavigator*)(self) )->QPdfPageNavigator::eventFilter(watched, event); + +} + +bool QPdfPageNavigator_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator* self_cast = dynamic_cast( (QPdfPageNavigator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QPdfPageNavigator_virtualbase_timerEvent(void* self, QTimerEvent* event) { + + ( (MiqtVirtualQPdfPageNavigator*)(self) )->QPdfPageNavigator::timerEvent(event); + +} + +bool QPdfPageNavigator_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator* self_cast = dynamic_cast( (QPdfPageNavigator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QPdfPageNavigator_virtualbase_childEvent(void* self, QChildEvent* event) { + + ( (MiqtVirtualQPdfPageNavigator*)(self) )->QPdfPageNavigator::childEvent(event); + +} + +bool QPdfPageNavigator_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator* self_cast = dynamic_cast( (QPdfPageNavigator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QPdfPageNavigator_virtualbase_customEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfPageNavigator*)(self) )->QPdfPageNavigator::customEvent(event); + +} + +bool QPdfPageNavigator_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator* self_cast = dynamic_cast( (QPdfPageNavigator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QPdfPageNavigator_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfPageNavigator*)(self) )->QPdfPageNavigator::connectNotify(*signal); + +} + +bool QPdfPageNavigator_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfPageNavigator* self_cast = dynamic_cast( (QPdfPageNavigator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QPdfPageNavigator_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfPageNavigator*)(self) )->QPdfPageNavigator::disconnectNotify(*signal); + +} + +QPdfLink* QPdfPageNavigator_protectedbase_currentLink(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfPageNavigator* self_cast = dynamic_cast( (QPdfPageNavigator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return new QPdfLink(self_cast->currentLink()); + +} + +QObject* QPdfPageNavigator_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfPageNavigator* self_cast = dynamic_cast( (QPdfPageNavigator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return self_cast->sender(); + +} + +int QPdfPageNavigator_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfPageNavigator* self_cast = dynamic_cast( (QPdfPageNavigator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->senderSignalIndex(); + +} + +int QPdfPageNavigator_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQPdfPageNavigator* self_cast = dynamic_cast( (QPdfPageNavigator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->receivers(signal); + +} + +bool QPdfPageNavigator_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQPdfPageNavigator* self_cast = dynamic_cast( (QPdfPageNavigator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->isSignalConnected(*signal); + +} + +void QPdfPageNavigator_delete(QPdfPageNavigator* self) { + delete self; +} + diff --git a/qt6/pdf/gen_qpdfpagenavigator.go b/qt6/pdf/gen_qpdfpagenavigator.go new file mode 100644 index 00000000..ea0f6cfc --- /dev/null +++ b/qt6/pdf/gen_qpdfpagenavigator.go @@ -0,0 +1,555 @@ +package pdf + +/* + +#include "gen_qpdfpagenavigator.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QPdfPageNavigator struct { + h *C.QPdfPageNavigator + *qt6.QObject +} + +func (this *QPdfPageNavigator) cPointer() *C.QPdfPageNavigator { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfPageNavigator) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfPageNavigator constructs the type using only CGO pointers. +func newQPdfPageNavigator(h *C.QPdfPageNavigator) *QPdfPageNavigator { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QPdfPageNavigator_virtbase(h, &outptr_QObject) + + return &QPdfPageNavigator{h: h, + QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQPdfPageNavigator constructs the type using only unsafe pointers. +func UnsafeNewQPdfPageNavigator(h unsafe.Pointer) *QPdfPageNavigator { + return newQPdfPageNavigator((*C.QPdfPageNavigator)(h)) +} + +// NewQPdfPageNavigator constructs a new QPdfPageNavigator object. +func NewQPdfPageNavigator() *QPdfPageNavigator { + + return newQPdfPageNavigator(C.QPdfPageNavigator_new()) +} + +// NewQPdfPageNavigator2 constructs a new QPdfPageNavigator object. +func NewQPdfPageNavigator2(parent *qt6.QObject) *QPdfPageNavigator { + + return newQPdfPageNavigator(C.QPdfPageNavigator_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QPdfPageNavigator) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QPdfPageNavigator_metaObject(this.h))) +} + +func (this *QPdfPageNavigator) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QPdfPageNavigator_metacast(this.h, param1_Cstring)) +} + +func QPdfPageNavigator_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageNavigator_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfPageNavigator) CurrentPage() int { + return (int)(C.QPdfPageNavigator_currentPage(this.h)) +} + +func (this *QPdfPageNavigator) CurrentLocation() *qt6.QPointF { + _goptr := qt6.UnsafeNewQPointF(unsafe.Pointer(C.QPdfPageNavigator_currentLocation(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfPageNavigator) CurrentZoom() float64 { + return (float64)(C.QPdfPageNavigator_currentZoom(this.h)) +} + +func (this *QPdfPageNavigator) BackAvailable() bool { + return (bool)(C.QPdfPageNavigator_backAvailable(this.h)) +} + +func (this *QPdfPageNavigator) ForwardAvailable() bool { + return (bool)(C.QPdfPageNavigator_forwardAvailable(this.h)) +} + +func (this *QPdfPageNavigator) Clear() { + C.QPdfPageNavigator_clear(this.h) +} + +func (this *QPdfPageNavigator) Jump(destination QPdfLink) { + C.QPdfPageNavigator_jump(this.h, destination.cPointer()) +} + +func (this *QPdfPageNavigator) Jump2(page int, location *qt6.QPointF) { + C.QPdfPageNavigator_jump2(this.h, (C.int)(page), (*C.QPointF)(location.UnsafePointer())) +} + +func (this *QPdfPageNavigator) Update(page int, location *qt6.QPointF, zoom float64) { + C.QPdfPageNavigator_update(this.h, (C.int)(page), (*C.QPointF)(location.UnsafePointer()), (C.double)(zoom)) +} + +func (this *QPdfPageNavigator) Forward() { + C.QPdfPageNavigator_forward(this.h) +} + +func (this *QPdfPageNavigator) Back() { + C.QPdfPageNavigator_back(this.h) +} + +func (this *QPdfPageNavigator) CurrentPageChanged(page int) { + C.QPdfPageNavigator_currentPageChanged(this.h, (C.int)(page)) +} +func (this *QPdfPageNavigator) OnCurrentPageChanged(slot func(page int)) { + C.QPdfPageNavigator_connect_currentPageChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageNavigator_currentPageChanged +func miqt_exec_callback_QPdfPageNavigator_currentPageChanged(cb C.intptr_t, page C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(page int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(page) + + gofunc(slotval1) +} + +func (this *QPdfPageNavigator) CurrentLocationChanged(location qt6.QPointF) { + C.QPdfPageNavigator_currentLocationChanged(this.h, (*C.QPointF)(location.UnsafePointer())) +} +func (this *QPdfPageNavigator) OnCurrentLocationChanged(slot func(location qt6.QPointF)) { + C.QPdfPageNavigator_connect_currentLocationChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageNavigator_currentLocationChanged +func miqt_exec_callback_QPdfPageNavigator_currentLocationChanged(cb C.intptr_t, location *C.QPointF) { + gofunc, ok := cgo.Handle(cb).Value().(func(location qt6.QPointF)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + location_goptr := qt6.UnsafeNewQPointF(unsafe.Pointer(location)) + location_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + slotval1 := *location_goptr + + gofunc(slotval1) +} + +func (this *QPdfPageNavigator) CurrentZoomChanged(zoom float64) { + C.QPdfPageNavigator_currentZoomChanged(this.h, (C.double)(zoom)) +} +func (this *QPdfPageNavigator) OnCurrentZoomChanged(slot func(zoom float64)) { + C.QPdfPageNavigator_connect_currentZoomChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageNavigator_currentZoomChanged +func miqt_exec_callback_QPdfPageNavigator_currentZoomChanged(cb C.intptr_t, zoom C.double) { + gofunc, ok := cgo.Handle(cb).Value().(func(zoom float64)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (float64)(zoom) + + gofunc(slotval1) +} + +func (this *QPdfPageNavigator) BackAvailableChanged(available bool) { + C.QPdfPageNavigator_backAvailableChanged(this.h, (C.bool)(available)) +} +func (this *QPdfPageNavigator) OnBackAvailableChanged(slot func(available bool)) { + C.QPdfPageNavigator_connect_backAvailableChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageNavigator_backAvailableChanged +func miqt_exec_callback_QPdfPageNavigator_backAvailableChanged(cb C.intptr_t, available C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(available bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(available) + + gofunc(slotval1) +} + +func (this *QPdfPageNavigator) ForwardAvailableChanged(available bool) { + C.QPdfPageNavigator_forwardAvailableChanged(this.h, (C.bool)(available)) +} +func (this *QPdfPageNavigator) OnForwardAvailableChanged(slot func(available bool)) { + C.QPdfPageNavigator_connect_forwardAvailableChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageNavigator_forwardAvailableChanged +func miqt_exec_callback_QPdfPageNavigator_forwardAvailableChanged(cb C.intptr_t, available C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(available bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(available) + + gofunc(slotval1) +} + +func (this *QPdfPageNavigator) Jumped(current QPdfLink) { + C.QPdfPageNavigator_jumped(this.h, current.cPointer()) +} +func (this *QPdfPageNavigator) OnJumped(slot func(current QPdfLink)) { + C.QPdfPageNavigator_connect_jumped(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageNavigator_jumped +func miqt_exec_callback_QPdfPageNavigator_jumped(cb C.intptr_t, current *C.QPdfLink) { + gofunc, ok := cgo.Handle(cb).Value().(func(current QPdfLink)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + current_goptr := newQPdfLink(current) + current_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + slotval1 := *current_goptr + + gofunc(slotval1) +} + +func QPdfPageNavigator_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageNavigator_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfPageNavigator_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageNavigator_tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfPageNavigator) Jump3(page int, location *qt6.QPointF, zoom float64) { + C.QPdfPageNavigator_jump3(this.h, (C.int)(page), (*C.QPointF)(location.UnsafePointer()), (C.double)(zoom)) +} + +// CurrentLink can only be called from a QPdfPageNavigator that was directly constructed. +func (this *QPdfPageNavigator) CurrentLink() QPdfLink { + + var _dynamic_cast_ok C.bool = false + _goptr := newQPdfLink(C.QPdfPageNavigator_protectedbase_currentLink(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _method_ret := *_goptr + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Sender can only be called from a QPdfPageNavigator that was directly constructed. +func (this *QPdfPageNavigator) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QPdfPageNavigator_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// SenderSignalIndex can only be called from a QPdfPageNavigator that was directly constructed. +func (this *QPdfPageNavigator) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfPageNavigator_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Receivers can only be called from a QPdfPageNavigator that was directly constructed. +func (this *QPdfPageNavigator) Receivers(signal string) int { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfPageNavigator_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// IsSignalConnected can only be called from a QPdfPageNavigator that was directly constructed. +func (this *QPdfPageNavigator) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfPageNavigator_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +func (this *QPdfPageNavigator) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QPdfPageNavigator_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfPageNavigator) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QPdfPageNavigator_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigator_event +func miqt_exec_callback_QPdfPageNavigator_event(self *C.QPdfPageNavigator, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfPageNavigator{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfPageNavigator) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QPdfPageNavigator_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfPageNavigator) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QPdfPageNavigator_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigator_eventFilter +func miqt_exec_callback_QPdfPageNavigator_eventFilter(self *C.QPdfPageNavigator, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfPageNavigator{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfPageNavigator) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QPdfPageNavigator_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QPdfPageNavigator) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QPdfPageNavigator_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigator_timerEvent +func miqt_exec_callback_QPdfPageNavigator_timerEvent(self *C.QPdfPageNavigator, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QPdfPageNavigator{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QPdfPageNavigator) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QPdfPageNavigator_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QPdfPageNavigator) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QPdfPageNavigator_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigator_childEvent +func miqt_exec_callback_QPdfPageNavigator_childEvent(self *C.QPdfPageNavigator, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QPdfPageNavigator{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QPdfPageNavigator) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QPdfPageNavigator_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfPageNavigator) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QPdfPageNavigator_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigator_customEvent +func miqt_exec_callback_QPdfPageNavigator_customEvent(self *C.QPdfPageNavigator, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent), event *qt6.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfPageNavigator{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QPdfPageNavigator) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QPdfPageNavigator_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfPageNavigator) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QPdfPageNavigator_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigator_connectNotify +func miqt_exec_callback_QPdfPageNavigator_connectNotify(self *C.QPdfPageNavigator, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfPageNavigator{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QPdfPageNavigator) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QPdfPageNavigator_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfPageNavigator) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QPdfPageNavigator_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageNavigator_disconnectNotify +func miqt_exec_callback_QPdfPageNavigator_disconnectNotify(self *C.QPdfPageNavigator, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfPageNavigator{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QPdfPageNavigator) Delete() { + C.QPdfPageNavigator_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfPageNavigator) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfPageNavigator) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/pdf/gen_qpdfpagenavigator.h b/qt6/pdf/gen_qpdfpagenavigator.h new file mode 100644 index 00000000..bd6a1242 --- /dev/null +++ b/qt6/pdf/gen_qpdfpagenavigator.h @@ -0,0 +1,96 @@ +#pragma once +#ifndef MIQT_QT6_PDF_GEN_QPDFPAGENAVIGATOR_H +#define MIQT_QT6_PDF_GEN_QPDFPAGENAVIGATOR_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QChildEvent; +class QEvent; +class QMetaMethod; +class QMetaObject; +class QObject; +class QPdfLink; +class QPdfPageNavigator; +class QPointF; +class QTimerEvent; +#else +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QPdfLink QPdfLink; +typedef struct QPdfPageNavigator QPdfPageNavigator; +typedef struct QPointF QPointF; +typedef struct QTimerEvent QTimerEvent; +#endif + +QPdfPageNavigator* QPdfPageNavigator_new(); +QPdfPageNavigator* QPdfPageNavigator_new2(QObject* parent); +void QPdfPageNavigator_virtbase(QPdfPageNavigator* src, QObject** outptr_QObject); +QMetaObject* QPdfPageNavigator_metaObject(const QPdfPageNavigator* self); +void* QPdfPageNavigator_metacast(QPdfPageNavigator* self, const char* param1); +struct miqt_string QPdfPageNavigator_tr(const char* s); +int QPdfPageNavigator_currentPage(const QPdfPageNavigator* self); +QPointF* QPdfPageNavigator_currentLocation(const QPdfPageNavigator* self); +double QPdfPageNavigator_currentZoom(const QPdfPageNavigator* self); +bool QPdfPageNavigator_backAvailable(const QPdfPageNavigator* self); +bool QPdfPageNavigator_forwardAvailable(const QPdfPageNavigator* self); +void QPdfPageNavigator_clear(QPdfPageNavigator* self); +void QPdfPageNavigator_jump(QPdfPageNavigator* self, QPdfLink* destination); +void QPdfPageNavigator_jump2(QPdfPageNavigator* self, int page, QPointF* location); +void QPdfPageNavigator_update(QPdfPageNavigator* self, int page, QPointF* location, double zoom); +void QPdfPageNavigator_forward(QPdfPageNavigator* self); +void QPdfPageNavigator_back(QPdfPageNavigator* self); +void QPdfPageNavigator_currentPageChanged(QPdfPageNavigator* self, int page); +void QPdfPageNavigator_connect_currentPageChanged(QPdfPageNavigator* self, intptr_t slot); +void QPdfPageNavigator_currentLocationChanged(QPdfPageNavigator* self, QPointF* location); +void QPdfPageNavigator_connect_currentLocationChanged(QPdfPageNavigator* self, intptr_t slot); +void QPdfPageNavigator_currentZoomChanged(QPdfPageNavigator* self, double zoom); +void QPdfPageNavigator_connect_currentZoomChanged(QPdfPageNavigator* self, intptr_t slot); +void QPdfPageNavigator_backAvailableChanged(QPdfPageNavigator* self, bool available); +void QPdfPageNavigator_connect_backAvailableChanged(QPdfPageNavigator* self, intptr_t slot); +void QPdfPageNavigator_forwardAvailableChanged(QPdfPageNavigator* self, bool available); +void QPdfPageNavigator_connect_forwardAvailableChanged(QPdfPageNavigator* self, intptr_t slot); +void QPdfPageNavigator_jumped(QPdfPageNavigator* self, QPdfLink* current); +void QPdfPageNavigator_connect_jumped(QPdfPageNavigator* self, intptr_t slot); +struct miqt_string QPdfPageNavigator_tr2(const char* s, const char* c); +struct miqt_string QPdfPageNavigator_tr3(const char* s, const char* c, int n); +void QPdfPageNavigator_jump3(QPdfPageNavigator* self, int page, QPointF* location, double zoom); +bool QPdfPageNavigator_override_virtual_event(void* self, intptr_t slot); +bool QPdfPageNavigator_virtualbase_event(void* self, QEvent* event); +bool QPdfPageNavigator_override_virtual_eventFilter(void* self, intptr_t slot); +bool QPdfPageNavigator_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QPdfPageNavigator_override_virtual_timerEvent(void* self, intptr_t slot); +void QPdfPageNavigator_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QPdfPageNavigator_override_virtual_childEvent(void* self, intptr_t slot); +void QPdfPageNavigator_virtualbase_childEvent(void* self, QChildEvent* event); +bool QPdfPageNavigator_override_virtual_customEvent(void* self, intptr_t slot); +void QPdfPageNavigator_virtualbase_customEvent(void* self, QEvent* event); +bool QPdfPageNavigator_override_virtual_connectNotify(void* self, intptr_t slot); +void QPdfPageNavigator_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QPdfPageNavigator_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QPdfPageNavigator_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); +QPdfLink* QPdfPageNavigator_protectedbase_currentLink(bool* _dynamic_cast_ok, const void* self); +QObject* QPdfPageNavigator_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QPdfPageNavigator_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QPdfPageNavigator_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QPdfPageNavigator_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +void QPdfPageNavigator_delete(QPdfPageNavigator* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/pdf/gen_qpdfpagerenderer.cpp b/qt6/pdf/gen_qpdfpagerenderer.cpp new file mode 100644 index 00000000..300a0ba2 --- /dev/null +++ b/qt6/pdf/gen_qpdfpagerenderer.cpp @@ -0,0 +1,475 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qpdfpagerenderer.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QPdfPageRenderer_documentChanged(intptr_t, QPdfDocument*); +void miqt_exec_callback_QPdfPageRenderer_renderModeChanged(intptr_t, int); +void miqt_exec_callback_QPdfPageRenderer_pageRendered(intptr_t, int, QSize*, QImage*, QPdfDocumentRenderOptions*, unsigned long long); +bool miqt_exec_callback_QPdfPageRenderer_event(QPdfPageRenderer*, intptr_t, QEvent*); +bool miqt_exec_callback_QPdfPageRenderer_eventFilter(QPdfPageRenderer*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QPdfPageRenderer_timerEvent(QPdfPageRenderer*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QPdfPageRenderer_childEvent(QPdfPageRenderer*, intptr_t, QChildEvent*); +void miqt_exec_callback_QPdfPageRenderer_customEvent(QPdfPageRenderer*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfPageRenderer_connectNotify(QPdfPageRenderer*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QPdfPageRenderer_disconnectNotify(QPdfPageRenderer*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQPdfPageRenderer final : public QPdfPageRenderer { +public: + + MiqtVirtualQPdfPageRenderer(): QPdfPageRenderer() {}; + MiqtVirtualQPdfPageRenderer(QObject* parent): QPdfPageRenderer(parent) {}; + + virtual ~MiqtVirtualQPdfPageRenderer() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QPdfPageRenderer::event(event); + } + + QEvent* sigval1 = event; + + bool callback_return_value = miqt_exec_callback_QPdfPageRenderer_event(this, handle__event, sigval1); + + return callback_return_value; + } + + friend bool QPdfPageRenderer_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QPdfPageRenderer::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + + bool callback_return_value = miqt_exec_callback_QPdfPageRenderer_eventFilter(this, handle__eventFilter, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfPageRenderer_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__timerEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void timerEvent(QTimerEvent* event) override { + if (handle__timerEvent == 0) { + QPdfPageRenderer::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + + miqt_exec_callback_QPdfPageRenderer_timerEvent(this, handle__timerEvent, sigval1); + + + } + + friend void QPdfPageRenderer_virtualbase_timerEvent(void* self, QTimerEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__childEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void childEvent(QChildEvent* event) override { + if (handle__childEvent == 0) { + QPdfPageRenderer::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + + miqt_exec_callback_QPdfPageRenderer_childEvent(this, handle__childEvent, sigval1); + + + } + + friend void QPdfPageRenderer_virtualbase_childEvent(void* self, QChildEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__customEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void customEvent(QEvent* event) override { + if (handle__customEvent == 0) { + QPdfPageRenderer::customEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfPageRenderer_customEvent(this, handle__customEvent, sigval1); + + + } + + friend void QPdfPageRenderer_virtualbase_customEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__connectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void connectNotify(const QMetaMethod& signal) override { + if (handle__connectNotify == 0) { + QPdfPageRenderer::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfPageRenderer_connectNotify(this, handle__connectNotify, sigval1); + + + } + + friend void QPdfPageRenderer_virtualbase_connectNotify(void* self, QMetaMethod* signal); + + // cgo.Handle value for overwritten implementation + intptr_t handle__disconnectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void disconnectNotify(const QMetaMethod& signal) override { + if (handle__disconnectNotify == 0) { + QPdfPageRenderer::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfPageRenderer_disconnectNotify(this, handle__disconnectNotify, sigval1); + + + } + + friend void QPdfPageRenderer_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QPdfPageRenderer_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QPdfPageRenderer_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QPdfPageRenderer_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QPdfPageRenderer_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QPdfPageRenderer* QPdfPageRenderer_new() { + return new MiqtVirtualQPdfPageRenderer(); +} + +QPdfPageRenderer* QPdfPageRenderer_new2(QObject* parent) { + return new MiqtVirtualQPdfPageRenderer(parent); +} + +void QPdfPageRenderer_virtbase(QPdfPageRenderer* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QPdfPageRenderer_metaObject(const QPdfPageRenderer* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QPdfPageRenderer_metacast(QPdfPageRenderer* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QPdfPageRenderer_tr(const char* s) { + QString _ret = QPdfPageRenderer::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; +} + +int QPdfPageRenderer_renderMode(const QPdfPageRenderer* self) { + QPdfPageRenderer::RenderMode _ret = self->renderMode(); + return static_cast(_ret); +} + +void QPdfPageRenderer_setRenderMode(QPdfPageRenderer* self, int mode) { + self->setRenderMode(static_cast(mode)); +} + +QPdfDocument* QPdfPageRenderer_document(const QPdfPageRenderer* self) { + return self->document(); +} + +void QPdfPageRenderer_setDocument(QPdfPageRenderer* self, QPdfDocument* document) { + self->setDocument(document); +} + +unsigned long long QPdfPageRenderer_requestPage(QPdfPageRenderer* self, int pageNumber, QSize* imageSize) { + quint64 _ret = self->requestPage(static_cast(pageNumber), *imageSize); + return static_cast(_ret); +} + +void QPdfPageRenderer_documentChanged(QPdfPageRenderer* self, QPdfDocument* document) { + self->documentChanged(document); +} + +void QPdfPageRenderer_connect_documentChanged(QPdfPageRenderer* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer::connect(self, static_cast(&QPdfPageRenderer::documentChanged), self, [=](QPdfDocument* document) { + QPdfDocument* sigval1 = document; + miqt_exec_callback_QPdfPageRenderer_documentChanged(slot, sigval1); + }); +} + +void QPdfPageRenderer_renderModeChanged(QPdfPageRenderer* self, int renderMode) { + self->renderModeChanged(static_cast(renderMode)); +} + +void QPdfPageRenderer_connect_renderModeChanged(QPdfPageRenderer* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer::connect(self, static_cast(&QPdfPageRenderer::renderModeChanged), self, [=](QPdfPageRenderer::RenderMode renderMode) { + QPdfPageRenderer::RenderMode renderMode_ret = renderMode; + int sigval1 = static_cast(renderMode_ret); + miqt_exec_callback_QPdfPageRenderer_renderModeChanged(slot, sigval1); + }); +} + +void QPdfPageRenderer_pageRendered(QPdfPageRenderer* self, int pageNumber, QSize* imageSize, QImage* image, QPdfDocumentRenderOptions* options, unsigned long long requestId) { + self->pageRendered(static_cast(pageNumber), *imageSize, *image, *options, static_cast(requestId)); +} + +void QPdfPageRenderer_connect_pageRendered(QPdfPageRenderer* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer::connect(self, static_cast(&QPdfPageRenderer::pageRendered), self, [=](int pageNumber, QSize imageSize, const QImage& image, QPdfDocumentRenderOptions options, quint64 requestId) { + int sigval1 = pageNumber; + QSize* sigval2 = new QSize(imageSize); + const QImage& image_ret = image; + // Cast returned reference into pointer + QImage* sigval3 = const_cast(&image_ret); + QPdfDocumentRenderOptions* sigval4 = new QPdfDocumentRenderOptions(options); + quint64 requestId_ret = requestId; + unsigned long long sigval5 = static_cast(requestId_ret); + miqt_exec_callback_QPdfPageRenderer_pageRendered(slot, sigval1, sigval2, sigval3, sigval4, sigval5); + }); +} + +struct miqt_string QPdfPageRenderer_tr2(const char* s, const char* c) { + QString _ret = QPdfPageRenderer::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 QPdfPageRenderer_tr3(const char* s, const char* c, int n) { + QString _ret = QPdfPageRenderer::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; +} + +unsigned long long QPdfPageRenderer_requestPage2(QPdfPageRenderer* self, int pageNumber, QSize* imageSize, QPdfDocumentRenderOptions* options) { + quint64 _ret = self->requestPage(static_cast(pageNumber), *imageSize, *options); + return static_cast(_ret); +} + +bool QPdfPageRenderer_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QPdfPageRenderer_virtualbase_event(void* self, QEvent* event) { + + return ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::event(event); + +} + +bool QPdfPageRenderer_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QPdfPageRenderer_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + + return ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::eventFilter(watched, event); + +} + +bool QPdfPageRenderer_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QPdfPageRenderer_virtualbase_timerEvent(void* self, QTimerEvent* event) { + + ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::timerEvent(event); + +} + +bool QPdfPageRenderer_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QPdfPageRenderer_virtualbase_childEvent(void* self, QChildEvent* event) { + + ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::childEvent(event); + +} + +bool QPdfPageRenderer_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QPdfPageRenderer_virtualbase_customEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::customEvent(event); + +} + +bool QPdfPageRenderer_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QPdfPageRenderer_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::connectNotify(*signal); + +} + +bool QPdfPageRenderer_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QPdfPageRenderer_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfPageRenderer*)(self) )->QPdfPageRenderer::disconnectNotify(*signal); + +} + +QObject* QPdfPageRenderer_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return self_cast->sender(); + +} + +int QPdfPageRenderer_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->senderSignalIndex(); + +} + +int QPdfPageRenderer_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->receivers(signal); + +} + +bool QPdfPageRenderer_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQPdfPageRenderer* self_cast = dynamic_cast( (QPdfPageRenderer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->isSignalConnected(*signal); + +} + +void QPdfPageRenderer_delete(QPdfPageRenderer* self) { + delete self; +} + diff --git a/qt6/pdf/gen_qpdfpagerenderer.go b/qt6/pdf/gen_qpdfpagerenderer.go new file mode 100644 index 00000000..52ccbee2 --- /dev/null +++ b/qt6/pdf/gen_qpdfpagerenderer.go @@ -0,0 +1,468 @@ +package pdf + +/* + +#include "gen_qpdfpagerenderer.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QPdfPageRenderer__RenderMode int + +const ( + QPdfPageRenderer__MultiThreaded QPdfPageRenderer__RenderMode = 0 + QPdfPageRenderer__SingleThreaded QPdfPageRenderer__RenderMode = 1 +) + +type QPdfPageRenderer struct { + h *C.QPdfPageRenderer + *qt6.QObject +} + +func (this *QPdfPageRenderer) cPointer() *C.QPdfPageRenderer { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfPageRenderer) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfPageRenderer constructs the type using only CGO pointers. +func newQPdfPageRenderer(h *C.QPdfPageRenderer) *QPdfPageRenderer { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QPdfPageRenderer_virtbase(h, &outptr_QObject) + + return &QPdfPageRenderer{h: h, + QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQPdfPageRenderer constructs the type using only unsafe pointers. +func UnsafeNewQPdfPageRenderer(h unsafe.Pointer) *QPdfPageRenderer { + return newQPdfPageRenderer((*C.QPdfPageRenderer)(h)) +} + +// NewQPdfPageRenderer constructs a new QPdfPageRenderer object. +func NewQPdfPageRenderer() *QPdfPageRenderer { + + return newQPdfPageRenderer(C.QPdfPageRenderer_new()) +} + +// NewQPdfPageRenderer2 constructs a new QPdfPageRenderer object. +func NewQPdfPageRenderer2(parent *qt6.QObject) *QPdfPageRenderer { + + return newQPdfPageRenderer(C.QPdfPageRenderer_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QPdfPageRenderer) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QPdfPageRenderer_metaObject(this.h))) +} + +func (this *QPdfPageRenderer) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QPdfPageRenderer_metacast(this.h, param1_Cstring)) +} + +func QPdfPageRenderer_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageRenderer_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfPageRenderer) RenderMode() QPdfPageRenderer__RenderMode { + return (QPdfPageRenderer__RenderMode)(C.QPdfPageRenderer_renderMode(this.h)) +} + +func (this *QPdfPageRenderer) SetRenderMode(mode QPdfPageRenderer__RenderMode) { + C.QPdfPageRenderer_setRenderMode(this.h, (C.int)(mode)) +} + +func (this *QPdfPageRenderer) Document() *QPdfDocument { + return newQPdfDocument(C.QPdfPageRenderer_document(this.h)) +} + +func (this *QPdfPageRenderer) SetDocument(document *QPdfDocument) { + C.QPdfPageRenderer_setDocument(this.h, document.cPointer()) +} + +func (this *QPdfPageRenderer) RequestPage(pageNumber int, imageSize qt6.QSize) uint64 { + return (uint64)(C.QPdfPageRenderer_requestPage(this.h, (C.int)(pageNumber), (*C.QSize)(imageSize.UnsafePointer()))) +} + +func (this *QPdfPageRenderer) DocumentChanged(document *QPdfDocument) { + C.QPdfPageRenderer_documentChanged(this.h, document.cPointer()) +} +func (this *QPdfPageRenderer) OnDocumentChanged(slot func(document *QPdfDocument)) { + C.QPdfPageRenderer_connect_documentChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageRenderer_documentChanged +func miqt_exec_callback_QPdfPageRenderer_documentChanged(cb C.intptr_t, document *C.QPdfDocument) { + gofunc, ok := cgo.Handle(cb).Value().(func(document *QPdfDocument)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQPdfDocument(document) + + gofunc(slotval1) +} + +func (this *QPdfPageRenderer) RenderModeChanged(renderMode QPdfPageRenderer__RenderMode) { + C.QPdfPageRenderer_renderModeChanged(this.h, (C.int)(renderMode)) +} +func (this *QPdfPageRenderer) OnRenderModeChanged(slot func(renderMode QPdfPageRenderer__RenderMode)) { + C.QPdfPageRenderer_connect_renderModeChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageRenderer_renderModeChanged +func miqt_exec_callback_QPdfPageRenderer_renderModeChanged(cb C.intptr_t, renderMode C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(renderMode QPdfPageRenderer__RenderMode)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (QPdfPageRenderer__RenderMode)(renderMode) + + gofunc(slotval1) +} + +func (this *QPdfPageRenderer) PageRendered(pageNumber int, imageSize qt6.QSize, image *qt6.QImage, options QPdfDocumentRenderOptions, requestId uint64) { + C.QPdfPageRenderer_pageRendered(this.h, (C.int)(pageNumber), (*C.QSize)(imageSize.UnsafePointer()), (*C.QImage)(image.UnsafePointer()), options.cPointer(), (C.ulonglong)(requestId)) +} +func (this *QPdfPageRenderer) OnPageRendered(slot func(pageNumber int, imageSize qt6.QSize, image *qt6.QImage, options QPdfDocumentRenderOptions, requestId uint64)) { + C.QPdfPageRenderer_connect_pageRendered(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfPageRenderer_pageRendered +func miqt_exec_callback_QPdfPageRenderer_pageRendered(cb C.intptr_t, pageNumber C.int, imageSize *C.QSize, image *C.QImage, options *C.QPdfDocumentRenderOptions, requestId C.ulonglong) { + gofunc, ok := cgo.Handle(cb).Value().(func(pageNumber int, imageSize qt6.QSize, image *qt6.QImage, options QPdfDocumentRenderOptions, requestId uint64)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(pageNumber) + + imageSize_goptr := qt6.UnsafeNewQSize(unsafe.Pointer(imageSize)) + imageSize_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + slotval2 := *imageSize_goptr + + slotval3 := qt6.UnsafeNewQImage(unsafe.Pointer(image)) + + options_goptr := newQPdfDocumentRenderOptions(options) + options_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + slotval4 := *options_goptr + + slotval5 := (uint64)(requestId) + + gofunc(slotval1, slotval2, slotval3, slotval4, slotval5) +} + +func QPdfPageRenderer_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageRenderer_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfPageRenderer_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfPageRenderer_tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfPageRenderer) RequestPage2(pageNumber int, imageSize qt6.QSize, options QPdfDocumentRenderOptions) uint64 { + return (uint64)(C.QPdfPageRenderer_requestPage2(this.h, (C.int)(pageNumber), (*C.QSize)(imageSize.UnsafePointer()), options.cPointer())) +} + +// Sender can only be called from a QPdfPageRenderer that was directly constructed. +func (this *QPdfPageRenderer) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QPdfPageRenderer_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// SenderSignalIndex can only be called from a QPdfPageRenderer that was directly constructed. +func (this *QPdfPageRenderer) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfPageRenderer_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Receivers can only be called from a QPdfPageRenderer that was directly constructed. +func (this *QPdfPageRenderer) Receivers(signal string) int { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfPageRenderer_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// IsSignalConnected can only be called from a QPdfPageRenderer that was directly constructed. +func (this *QPdfPageRenderer) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfPageRenderer_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +func (this *QPdfPageRenderer) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QPdfPageRenderer_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfPageRenderer) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QPdfPageRenderer_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_event +func miqt_exec_callback_QPdfPageRenderer_event(self *C.QPdfPageRenderer, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfPageRenderer) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QPdfPageRenderer_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfPageRenderer) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QPdfPageRenderer_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_eventFilter +func miqt_exec_callback_QPdfPageRenderer_eventFilter(self *C.QPdfPageRenderer, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfPageRenderer) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QPdfPageRenderer_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QPdfPageRenderer) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QPdfPageRenderer_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_timerEvent +func miqt_exec_callback_QPdfPageRenderer_timerEvent(self *C.QPdfPageRenderer, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QPdfPageRenderer) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QPdfPageRenderer_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QPdfPageRenderer) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QPdfPageRenderer_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_childEvent +func miqt_exec_callback_QPdfPageRenderer_childEvent(self *C.QPdfPageRenderer, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QPdfPageRenderer) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QPdfPageRenderer_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfPageRenderer) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QPdfPageRenderer_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_customEvent +func miqt_exec_callback_QPdfPageRenderer_customEvent(self *C.QPdfPageRenderer, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent), event *qt6.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QPdfPageRenderer) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QPdfPageRenderer_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfPageRenderer) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QPdfPageRenderer_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_connectNotify +func miqt_exec_callback_QPdfPageRenderer_connectNotify(self *C.QPdfPageRenderer, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QPdfPageRenderer) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QPdfPageRenderer_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfPageRenderer) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QPdfPageRenderer_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfPageRenderer_disconnectNotify +func miqt_exec_callback_QPdfPageRenderer_disconnectNotify(self *C.QPdfPageRenderer, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfPageRenderer{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QPdfPageRenderer) Delete() { + C.QPdfPageRenderer_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfPageRenderer) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfPageRenderer) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/pdf/gen_qpdfpagerenderer.h b/qt6/pdf/gen_qpdfpagerenderer.h new file mode 100644 index 00000000..682b49ad --- /dev/null +++ b/qt6/pdf/gen_qpdfpagerenderer.h @@ -0,0 +1,87 @@ +#pragma once +#ifndef MIQT_QT6_PDF_GEN_QPDFPAGERENDERER_H +#define MIQT_QT6_PDF_GEN_QPDFPAGERENDERER_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QChildEvent; +class QEvent; +class QImage; +class QMetaMethod; +class QMetaObject; +class QObject; +class QPdfDocument; +class QPdfDocumentRenderOptions; +class QPdfPageRenderer; +class QSize; +class QTimerEvent; +#else +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QImage QImage; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QPdfDocument QPdfDocument; +typedef struct QPdfDocumentRenderOptions QPdfDocumentRenderOptions; +typedef struct QPdfPageRenderer QPdfPageRenderer; +typedef struct QSize QSize; +typedef struct QTimerEvent QTimerEvent; +#endif + +QPdfPageRenderer* QPdfPageRenderer_new(); +QPdfPageRenderer* QPdfPageRenderer_new2(QObject* parent); +void QPdfPageRenderer_virtbase(QPdfPageRenderer* src, QObject** outptr_QObject); +QMetaObject* QPdfPageRenderer_metaObject(const QPdfPageRenderer* self); +void* QPdfPageRenderer_metacast(QPdfPageRenderer* self, const char* param1); +struct miqt_string QPdfPageRenderer_tr(const char* s); +int QPdfPageRenderer_renderMode(const QPdfPageRenderer* self); +void QPdfPageRenderer_setRenderMode(QPdfPageRenderer* self, int mode); +QPdfDocument* QPdfPageRenderer_document(const QPdfPageRenderer* self); +void QPdfPageRenderer_setDocument(QPdfPageRenderer* self, QPdfDocument* document); +unsigned long long QPdfPageRenderer_requestPage(QPdfPageRenderer* self, int pageNumber, QSize* imageSize); +void QPdfPageRenderer_documentChanged(QPdfPageRenderer* self, QPdfDocument* document); +void QPdfPageRenderer_connect_documentChanged(QPdfPageRenderer* self, intptr_t slot); +void QPdfPageRenderer_renderModeChanged(QPdfPageRenderer* self, int renderMode); +void QPdfPageRenderer_connect_renderModeChanged(QPdfPageRenderer* self, intptr_t slot); +void QPdfPageRenderer_pageRendered(QPdfPageRenderer* self, int pageNumber, QSize* imageSize, QImage* image, QPdfDocumentRenderOptions* options, unsigned long long requestId); +void QPdfPageRenderer_connect_pageRendered(QPdfPageRenderer* self, intptr_t slot); +struct miqt_string QPdfPageRenderer_tr2(const char* s, const char* c); +struct miqt_string QPdfPageRenderer_tr3(const char* s, const char* c, int n); +unsigned long long QPdfPageRenderer_requestPage2(QPdfPageRenderer* self, int pageNumber, QSize* imageSize, QPdfDocumentRenderOptions* options); +bool QPdfPageRenderer_override_virtual_event(void* self, intptr_t slot); +bool QPdfPageRenderer_virtualbase_event(void* self, QEvent* event); +bool QPdfPageRenderer_override_virtual_eventFilter(void* self, intptr_t slot); +bool QPdfPageRenderer_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QPdfPageRenderer_override_virtual_timerEvent(void* self, intptr_t slot); +void QPdfPageRenderer_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QPdfPageRenderer_override_virtual_childEvent(void* self, intptr_t slot); +void QPdfPageRenderer_virtualbase_childEvent(void* self, QChildEvent* event); +bool QPdfPageRenderer_override_virtual_customEvent(void* self, intptr_t slot); +void QPdfPageRenderer_virtualbase_customEvent(void* self, QEvent* event); +bool QPdfPageRenderer_override_virtual_connectNotify(void* self, intptr_t slot); +void QPdfPageRenderer_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QPdfPageRenderer_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QPdfPageRenderer_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); +QObject* QPdfPageRenderer_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QPdfPageRenderer_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QPdfPageRenderer_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QPdfPageRenderer_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +void QPdfPageRenderer_delete(QPdfPageRenderer* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/pdf/gen_qpdfsearchmodel.cpp b/qt6/pdf/gen_qpdfsearchmodel.cpp new file mode 100644 index 00000000..937376ac --- /dev/null +++ b/qt6/pdf/gen_qpdfsearchmodel.cpp @@ -0,0 +1,2245 @@ +#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_qpdfsearchmodel.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QPdfSearchModel_documentChanged(intptr_t); +void miqt_exec_callback_QPdfSearchModel_searchStringChanged(intptr_t); +struct miqt_map /* of int to struct miqt_string */ miqt_exec_callback_QPdfSearchModel_roleNames(const QPdfSearchModel*, intptr_t); +int miqt_exec_callback_QPdfSearchModel_rowCount(const QPdfSearchModel*, intptr_t, QModelIndex*); +QVariant* miqt_exec_callback_QPdfSearchModel_data(const QPdfSearchModel*, intptr_t, QModelIndex*, int); +void miqt_exec_callback_QPdfSearchModel_timerEvent(QPdfSearchModel*, intptr_t, QTimerEvent*); +QModelIndex* miqt_exec_callback_QPdfSearchModel_index(const QPdfSearchModel*, intptr_t, int, int, QModelIndex*); +QModelIndex* miqt_exec_callback_QPdfSearchModel_sibling(const QPdfSearchModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_dropMimeData(QPdfSearchModel*, intptr_t, QMimeData*, int, int, int, QModelIndex*); +int miqt_exec_callback_QPdfSearchModel_flags(const QPdfSearchModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_setData(QPdfSearchModel*, intptr_t, QModelIndex*, QVariant*, int); +QVariant* miqt_exec_callback_QPdfSearchModel_headerData(const QPdfSearchModel*, intptr_t, int, int, int); +bool miqt_exec_callback_QPdfSearchModel_setHeaderData(QPdfSearchModel*, intptr_t, int, int, QVariant*, int); +struct miqt_map /* of int to QVariant* */ miqt_exec_callback_QPdfSearchModel_itemData(const QPdfSearchModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_setItemData(QPdfSearchModel*, intptr_t, QModelIndex*, struct miqt_map /* of int to QVariant* */ ); +bool miqt_exec_callback_QPdfSearchModel_clearItemData(QPdfSearchModel*, intptr_t, QModelIndex*); +struct miqt_array /* of struct miqt_string */ miqt_exec_callback_QPdfSearchModel_mimeTypes(const QPdfSearchModel*, intptr_t); +QMimeData* miqt_exec_callback_QPdfSearchModel_mimeData(const QPdfSearchModel*, intptr_t, struct miqt_array /* of QModelIndex* */ ); +bool miqt_exec_callback_QPdfSearchModel_canDropMimeData(const QPdfSearchModel*, intptr_t, QMimeData*, int, int, int, QModelIndex*); +int miqt_exec_callback_QPdfSearchModel_supportedDropActions(const QPdfSearchModel*, intptr_t); +int miqt_exec_callback_QPdfSearchModel_supportedDragActions(const QPdfSearchModel*, intptr_t); +bool miqt_exec_callback_QPdfSearchModel_insertRows(QPdfSearchModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_insertColumns(QPdfSearchModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_removeRows(QPdfSearchModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_removeColumns(QPdfSearchModel*, intptr_t, int, int, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_moveRows(QPdfSearchModel*, intptr_t, QModelIndex*, int, int, QModelIndex*, int); +bool miqt_exec_callback_QPdfSearchModel_moveColumns(QPdfSearchModel*, intptr_t, QModelIndex*, int, int, QModelIndex*, int); +void miqt_exec_callback_QPdfSearchModel_fetchMore(QPdfSearchModel*, intptr_t, QModelIndex*); +bool miqt_exec_callback_QPdfSearchModel_canFetchMore(const QPdfSearchModel*, intptr_t, QModelIndex*); +void miqt_exec_callback_QPdfSearchModel_sort(QPdfSearchModel*, intptr_t, int, int); +QModelIndex* miqt_exec_callback_QPdfSearchModel_buddy(const QPdfSearchModel*, intptr_t, QModelIndex*); +struct miqt_array /* of QModelIndex* */ miqt_exec_callback_QPdfSearchModel_match(const QPdfSearchModel*, intptr_t, QModelIndex*, int, QVariant*, int, int); +QSize* miqt_exec_callback_QPdfSearchModel_span(const QPdfSearchModel*, intptr_t, QModelIndex*); +void miqt_exec_callback_QPdfSearchModel_multiData(const QPdfSearchModel*, intptr_t, QModelIndex*, QModelRoleDataSpan*); +bool miqt_exec_callback_QPdfSearchModel_submit(QPdfSearchModel*, intptr_t); +void miqt_exec_callback_QPdfSearchModel_revert(QPdfSearchModel*, intptr_t); +void miqt_exec_callback_QPdfSearchModel_resetInternalData(QPdfSearchModel*, intptr_t); +bool miqt_exec_callback_QPdfSearchModel_event(QPdfSearchModel*, intptr_t, QEvent*); +bool miqt_exec_callback_QPdfSearchModel_eventFilter(QPdfSearchModel*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QPdfSearchModel_childEvent(QPdfSearchModel*, intptr_t, QChildEvent*); +void miqt_exec_callback_QPdfSearchModel_customEvent(QPdfSearchModel*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfSearchModel_connectNotify(QPdfSearchModel*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QPdfSearchModel_disconnectNotify(QPdfSearchModel*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQPdfSearchModel final : public QPdfSearchModel { +public: + + MiqtVirtualQPdfSearchModel(): QPdfSearchModel() {}; + MiqtVirtualQPdfSearchModel(QObject* parent): QPdfSearchModel(parent) {}; + + virtual ~MiqtVirtualQPdfSearchModel() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__roleNames = 0; + + // Subclass to allow providing a Go implementation + virtual QHash roleNames() const override { + if (handle__roleNames == 0) { + return QPdfSearchModel::roleNames(); + } + + + struct miqt_map /* of int to struct miqt_string */ callback_return_value = miqt_exec_callback_QPdfSearchModel_roleNames(this, handle__roleNames); + QHash callback_return_value_QMap; + callback_return_value_QMap.reserve(callback_return_value.len); + int* callback_return_value_karr = static_cast(callback_return_value.keys); + struct miqt_string* callback_return_value_varr = static_cast(callback_return_value.values); + for(size_t i = 0; i < callback_return_value.len; ++i) { + QByteArray callback_return_value_varr_i_QByteArray(callback_return_value_varr[i].data, callback_return_value_varr[i].len); + callback_return_value_QMap[static_cast(callback_return_value_karr[i])] = callback_return_value_varr_i_QByteArray; + } + + return callback_return_value_QMap; + } + + friend struct miqt_map /* of int to struct miqt_string */ QPdfSearchModel_virtualbase_roleNames(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__rowCount = 0; + + // Subclass to allow providing a Go implementation + virtual int rowCount(const QModelIndex& parent) const override { + if (handle__rowCount == 0) { + return QPdfSearchModel::rowCount(parent); + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + int callback_return_value = miqt_exec_callback_QPdfSearchModel_rowCount(this, handle__rowCount, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfSearchModel_virtualbase_rowCount(const void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__data = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant data(const QModelIndex& index, int role) const override { + if (handle__data == 0) { + return QPdfSearchModel::data(index, role); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + int sigval2 = role; + + QVariant* callback_return_value = miqt_exec_callback_QPdfSearchModel_data(this, handle__data, sigval1, sigval2); + + return *callback_return_value; + } + + friend QVariant* QPdfSearchModel_virtualbase_data(const void* self, QModelIndex* index, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__timerEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void timerEvent(QTimerEvent* event) override { + if (handle__timerEvent == 0) { + QPdfSearchModel::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + + miqt_exec_callback_QPdfSearchModel_timerEvent(this, handle__timerEvent, sigval1); + + + } + + friend void QPdfSearchModel_virtualbase_timerEvent(void* self, QTimerEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__index = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex index(int row, int column, const QModelIndex& parent) const override { + if (handle__index == 0) { + return QPdfSearchModel::index(row, column, parent); + } + + int sigval1 = row; + int sigval2 = column; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfSearchModel_index(this, handle__index, sigval1, sigval2, sigval3); + + return *callback_return_value; + } + + friend QModelIndex* QPdfSearchModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__sibling = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex sibling(int row, int column, const QModelIndex& idx) const override { + if (handle__sibling == 0) { + return QPdfSearchModel::sibling(row, column, idx); + } + + int sigval1 = row; + int sigval2 = column; + const QModelIndex& idx_ret = idx; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&idx_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfSearchModel_sibling(this, handle__sibling, sigval1, sigval2, sigval3); + + return *callback_return_value; + } + + friend QModelIndex* QPdfSearchModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx); + + // cgo.Handle value for overwritten implementation + intptr_t handle__dropMimeData = 0; + + // Subclass to allow providing a Go implementation + virtual bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override { + if (handle__dropMimeData == 0) { + return QPdfSearchModel::dropMimeData(data, action, row, column, parent); + } + + QMimeData* sigval1 = (QMimeData*) data; + Qt::DropAction action_ret = action; + int sigval2 = static_cast(action_ret); + int sigval3 = row; + int sigval4 = column; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval5 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_dropMimeData(this, handle__dropMimeData, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__flags = 0; + + // Subclass to allow providing a Go implementation + virtual Qt::ItemFlags flags(const QModelIndex& index) const override { + if (handle__flags == 0) { + return QPdfSearchModel::flags(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + int callback_return_value = miqt_exec_callback_QPdfSearchModel_flags(this, handle__flags, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfSearchModel_virtualbase_flags(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setData = 0; + + // Subclass to allow providing a Go implementation + virtual bool setData(const QModelIndex& index, const QVariant& value, int role) override { + if (handle__setData == 0) { + return QPdfSearchModel::setData(index, value, role); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval2 = const_cast(&value_ret); + int sigval3 = role; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_setData(this, handle__setData, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__headerData = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant headerData(int section, Qt::Orientation orientation, int role) const override { + if (handle__headerData == 0) { + return QPdfSearchModel::headerData(section, orientation, role); + } + + int sigval1 = section; + Qt::Orientation orientation_ret = orientation; + int sigval2 = static_cast(orientation_ret); + int sigval3 = role; + + QVariant* callback_return_value = miqt_exec_callback_QPdfSearchModel_headerData(this, handle__headerData, sigval1, sigval2, sigval3); + + return *callback_return_value; + } + + friend QVariant* QPdfSearchModel_virtualbase_headerData(const void* self, int section, int orientation, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setHeaderData = 0; + + // Subclass to allow providing a Go implementation + virtual bool setHeaderData(int section, Qt::Orientation orientation, const QVariant& value, int role) override { + if (handle__setHeaderData == 0) { + return QPdfSearchModel::setHeaderData(section, orientation, value, role); + } + + int sigval1 = section; + Qt::Orientation orientation_ret = orientation; + int sigval2 = static_cast(orientation_ret); + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval3 = const_cast(&value_ret); + int sigval4 = role; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_setHeaderData(this, handle__setHeaderData, sigval1, sigval2, sigval3, sigval4); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role); + + // cgo.Handle value for overwritten implementation + intptr_t handle__itemData = 0; + + // Subclass to allow providing a Go implementation + virtual QMap itemData(const QModelIndex& index) const override { + if (handle__itemData == 0) { + return QPdfSearchModel::itemData(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + struct miqt_map /* of int to QVariant* */ callback_return_value = miqt_exec_callback_QPdfSearchModel_itemData(this, handle__itemData, sigval1); + QMap callback_return_value_QMap; + int* callback_return_value_karr = static_cast(callback_return_value.keys); + QVariant** callback_return_value_varr = static_cast(callback_return_value.values); + for(size_t i = 0; i < callback_return_value.len; ++i) { + callback_return_value_QMap[static_cast(callback_return_value_karr[i])] = *(callback_return_value_varr[i]); + } + + return callback_return_value_QMap; + } + + friend struct miqt_map /* of int to QVariant* */ QPdfSearchModel_virtualbase_itemData(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setItemData = 0; + + // Subclass to allow providing a Go implementation + virtual bool setItemData(const QModelIndex& index, const QMap& roles) override { + if (handle__setItemData == 0) { + return QPdfSearchModel::setItemData(index, roles); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + const QMap& roles_ret = roles; + // Convert QMap<> from C++ memory to manually-managed C memory + int* roles_karr = static_cast(malloc(sizeof(int) * roles_ret.size())); + QVariant** roles_varr = static_cast(malloc(sizeof(QVariant*) * roles_ret.size())); + int roles_ctr = 0; + for (auto roles_itr = roles_ret.keyValueBegin(); roles_itr != roles_ret.keyValueEnd(); ++roles_itr) { + roles_karr[roles_ctr] = roles_itr->first; + roles_varr[roles_ctr] = new QVariant(roles_itr->second); + roles_ctr++; + } + struct miqt_map roles_out; + roles_out.len = roles_ret.size(); + roles_out.keys = static_cast(roles_karr); + roles_out.values = static_cast(roles_varr); + struct miqt_map /* of int to QVariant* */ sigval2 = roles_out; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_setItemData(this, handle__setItemData, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */ roles); + + // cgo.Handle value for overwritten implementation + intptr_t handle__clearItemData = 0; + + // Subclass to allow providing a Go implementation + virtual bool clearItemData(const QModelIndex& index) override { + if (handle__clearItemData == 0) { + return QPdfSearchModel::clearItemData(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_clearItemData(this, handle__clearItemData, sigval1); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_clearItemData(void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mimeTypes = 0; + + // Subclass to allow providing a Go implementation + virtual QStringList mimeTypes() const override { + if (handle__mimeTypes == 0) { + return QPdfSearchModel::mimeTypes(); + } + + + struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QPdfSearchModel_mimeTypes(this, handle__mimeTypes); + QStringList callback_return_value_QList; + callback_return_value_QList.reserve(callback_return_value.len); + struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); + for(size_t i = 0; i < callback_return_value.len; ++i) { + QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); + callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + } + + return callback_return_value_QList; + } + + friend struct miqt_array /* of struct miqt_string */ QPdfSearchModel_virtualbase_mimeTypes(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mimeData = 0; + + // Subclass to allow providing a Go implementation + virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + if (handle__mimeData == 0) { + return QPdfSearchModel::mimeData(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; + + QMimeData* callback_return_value = miqt_exec_callback_QPdfSearchModel_mimeData(this, handle__mimeData, sigval1); + + return callback_return_value; + } + + friend QMimeData* QPdfSearchModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes); + + // cgo.Handle value for overwritten implementation + intptr_t handle__canDropMimeData = 0; + + // Subclass to allow providing a Go implementation + virtual bool canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) const override { + if (handle__canDropMimeData == 0) { + return QPdfSearchModel::canDropMimeData(data, action, row, column, parent); + } + + QMimeData* sigval1 = (QMimeData*) data; + Qt::DropAction action_ret = action; + int sigval2 = static_cast(action_ret); + int sigval3 = row; + int sigval4 = column; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval5 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_canDropMimeData(this, handle__canDropMimeData, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__supportedDropActions = 0; + + // Subclass to allow providing a Go implementation + virtual Qt::DropActions supportedDropActions() const override { + if (handle__supportedDropActions == 0) { + return QPdfSearchModel::supportedDropActions(); + } + + + int callback_return_value = miqt_exec_callback_QPdfSearchModel_supportedDropActions(this, handle__supportedDropActions); + + return static_cast(callback_return_value); + } + + friend int QPdfSearchModel_virtualbase_supportedDropActions(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__supportedDragActions = 0; + + // Subclass to allow providing a Go implementation + virtual Qt::DropActions supportedDragActions() const override { + if (handle__supportedDragActions == 0) { + return QPdfSearchModel::supportedDragActions(); + } + + + int callback_return_value = miqt_exec_callback_QPdfSearchModel_supportedDragActions(this, handle__supportedDragActions); + + return static_cast(callback_return_value); + } + + friend int QPdfSearchModel_virtualbase_supportedDragActions(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__insertRows = 0; + + // Subclass to allow providing a Go implementation + virtual bool insertRows(int row, int count, const QModelIndex& parent) override { + if (handle__insertRows == 0) { + return QPdfSearchModel::insertRows(row, count, parent); + } + + int sigval1 = row; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_insertRows(this, handle__insertRows, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__insertColumns = 0; + + // Subclass to allow providing a Go implementation + virtual bool insertColumns(int column, int count, const QModelIndex& parent) override { + if (handle__insertColumns == 0) { + return QPdfSearchModel::insertColumns(column, count, parent); + } + + int sigval1 = column; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_insertColumns(this, handle__insertColumns, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__removeRows = 0; + + // Subclass to allow providing a Go implementation + virtual bool removeRows(int row, int count, const QModelIndex& parent) override { + if (handle__removeRows == 0) { + return QPdfSearchModel::removeRows(row, count, parent); + } + + int sigval1 = row; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_removeRows(this, handle__removeRows, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__removeColumns = 0; + + // Subclass to allow providing a Go implementation + virtual bool removeColumns(int column, int count, const QModelIndex& parent) override { + if (handle__removeColumns == 0) { + return QPdfSearchModel::removeColumns(column, count, parent); + } + + int sigval1 = column; + int sigval2 = count; + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval3 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_removeColumns(this, handle__removeColumns, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__moveRows = 0; + + // Subclass to allow providing a Go implementation + virtual bool moveRows(const QModelIndex& sourceParent, int sourceRow, int count, const QModelIndex& destinationParent, int destinationChild) override { + if (handle__moveRows == 0) { + return QPdfSearchModel::moveRows(sourceParent, sourceRow, count, destinationParent, destinationChild); + } + + const QModelIndex& sourceParent_ret = sourceParent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&sourceParent_ret); + int sigval2 = sourceRow; + int sigval3 = count; + const QModelIndex& destinationParent_ret = destinationParent; + // Cast returned reference into pointer + QModelIndex* sigval4 = const_cast(&destinationParent_ret); + int sigval5 = destinationChild; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_moveRows(this, handle__moveRows, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild); + + // cgo.Handle value for overwritten implementation + intptr_t handle__moveColumns = 0; + + // Subclass to allow providing a Go implementation + virtual bool moveColumns(const QModelIndex& sourceParent, int sourceColumn, int count, const QModelIndex& destinationParent, int destinationChild) override { + if (handle__moveColumns == 0) { + return QPdfSearchModel::moveColumns(sourceParent, sourceColumn, count, destinationParent, destinationChild); + } + + const QModelIndex& sourceParent_ret = sourceParent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&sourceParent_ret); + int sigval2 = sourceColumn; + int sigval3 = count; + const QModelIndex& destinationParent_ret = destinationParent; + // Cast returned reference into pointer + QModelIndex* sigval4 = const_cast(&destinationParent_ret); + int sigval5 = destinationChild; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_moveColumns(this, handle__moveColumns, sigval1, sigval2, sigval3, sigval4, sigval5); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild); + + // cgo.Handle value for overwritten implementation + intptr_t handle__fetchMore = 0; + + // Subclass to allow providing a Go implementation + virtual void fetchMore(const QModelIndex& parent) override { + if (handle__fetchMore == 0) { + QPdfSearchModel::fetchMore(parent); + return; + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + miqt_exec_callback_QPdfSearchModel_fetchMore(this, handle__fetchMore, sigval1); + + + } + + friend void QPdfSearchModel_virtualbase_fetchMore(void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__canFetchMore = 0; + + // Subclass to allow providing a Go implementation + virtual bool canFetchMore(const QModelIndex& parent) const override { + if (handle__canFetchMore == 0) { + return QPdfSearchModel::canFetchMore(parent); + } + + const QModelIndex& parent_ret = parent; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&parent_ret); + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_canFetchMore(this, handle__canFetchMore, sigval1); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__sort = 0; + + // Subclass to allow providing a Go implementation + virtual void sort(int column, Qt::SortOrder order) override { + if (handle__sort == 0) { + QPdfSearchModel::sort(column, order); + return; + } + + int sigval1 = column; + Qt::SortOrder order_ret = order; + int sigval2 = static_cast(order_ret); + + miqt_exec_callback_QPdfSearchModel_sort(this, handle__sort, sigval1, sigval2); + + + } + + friend void QPdfSearchModel_virtualbase_sort(void* self, int column, int order); + + // cgo.Handle value for overwritten implementation + intptr_t handle__buddy = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndex buddy(const QModelIndex& index) const override { + if (handle__buddy == 0) { + return QPdfSearchModel::buddy(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + QModelIndex* callback_return_value = miqt_exec_callback_QPdfSearchModel_buddy(this, handle__buddy, sigval1); + + return *callback_return_value; + } + + friend QModelIndex* QPdfSearchModel_virtualbase_buddy(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__match = 0; + + // Subclass to allow providing a Go implementation + virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + if (handle__match == 0) { + return QPdfSearchModel::match(start, role, value, hits, flags); + } + + const QModelIndex& start_ret = start; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&start_ret); + int sigval2 = role; + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval3 = const_cast(&value_ret); + int sigval4 = hits; + Qt::MatchFlags flags_ret = flags; + int sigval5 = static_cast(flags_ret); + + struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QPdfSearchModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); + 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; + } + + friend struct miqt_array /* of QModelIndex* */ QPdfSearchModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); + + // cgo.Handle value for overwritten implementation + intptr_t handle__span = 0; + + // Subclass to allow providing a Go implementation + virtual QSize span(const QModelIndex& index) const override { + if (handle__span == 0) { + return QPdfSearchModel::span(index); + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + + QSize* callback_return_value = miqt_exec_callback_QPdfSearchModel_span(this, handle__span, sigval1); + + return *callback_return_value; + } + + friend QSize* QPdfSearchModel_virtualbase_span(const void* self, QModelIndex* index); + + // cgo.Handle value for overwritten implementation + intptr_t handle__multiData = 0; + + // Subclass to allow providing a Go implementation + virtual void multiData(const QModelIndex& index, QModelRoleDataSpan roleDataSpan) const override { + if (handle__multiData == 0) { + QPdfSearchModel::multiData(index, roleDataSpan); + return; + } + + const QModelIndex& index_ret = index; + // Cast returned reference into pointer + QModelIndex* sigval1 = const_cast(&index_ret); + QModelRoleDataSpan* sigval2 = new QModelRoleDataSpan(roleDataSpan); + + miqt_exec_callback_QPdfSearchModel_multiData(this, handle__multiData, sigval1, sigval2); + + + } + + friend void QPdfSearchModel_virtualbase_multiData(const void* self, QModelIndex* index, QModelRoleDataSpan* roleDataSpan); + + // cgo.Handle value for overwritten implementation + intptr_t handle__submit = 0; + + // Subclass to allow providing a Go implementation + virtual bool submit() override { + if (handle__submit == 0) { + return QPdfSearchModel::submit(); + } + + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_submit(this, handle__submit); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_submit(void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__revert = 0; + + // Subclass to allow providing a Go implementation + virtual void revert() override { + if (handle__revert == 0) { + QPdfSearchModel::revert(); + return; + } + + + miqt_exec_callback_QPdfSearchModel_revert(this, handle__revert); + + + } + + friend void QPdfSearchModel_virtualbase_revert(void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__resetInternalData = 0; + + // Subclass to allow providing a Go implementation + virtual void resetInternalData() override { + if (handle__resetInternalData == 0) { + QPdfSearchModel::resetInternalData(); + return; + } + + + miqt_exec_callback_QPdfSearchModel_resetInternalData(this, handle__resetInternalData); + + + } + + friend void QPdfSearchModel_virtualbase_resetInternalData(void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QPdfSearchModel::event(event); + } + + QEvent* sigval1 = event; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_event(this, handle__event, sigval1); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QPdfSearchModel::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + + bool callback_return_value = miqt_exec_callback_QPdfSearchModel_eventFilter(this, handle__eventFilter, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfSearchModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__childEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void childEvent(QChildEvent* event) override { + if (handle__childEvent == 0) { + QPdfSearchModel::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + + miqt_exec_callback_QPdfSearchModel_childEvent(this, handle__childEvent, sigval1); + + + } + + friend void QPdfSearchModel_virtualbase_childEvent(void* self, QChildEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__customEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void customEvent(QEvent* event) override { + if (handle__customEvent == 0) { + QPdfSearchModel::customEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfSearchModel_customEvent(this, handle__customEvent, sigval1); + + + } + + friend void QPdfSearchModel_virtualbase_customEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__connectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void connectNotify(const QMetaMethod& signal) override { + if (handle__connectNotify == 0) { + QPdfSearchModel::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfSearchModel_connectNotify(this, handle__connectNotify, sigval1); + + + } + + friend void QPdfSearchModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); + + // cgo.Handle value for overwritten implementation + intptr_t handle__disconnectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void disconnectNotify(const QMetaMethod& signal) override { + if (handle__disconnectNotify == 0) { + QPdfSearchModel::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfSearchModel_disconnectNotify(this, handle__disconnectNotify, sigval1); + + + } + + friend void QPdfSearchModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend void QPdfSearchModel_protectedbase_updatePage(bool* _dynamic_cast_ok, void* self, int page); + friend QModelIndex* QPdfSearchModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column); + friend void QPdfSearchModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */ indexes, QDataStream* stream); + friend bool QPdfSearchModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream); + friend void QPdfSearchModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfSearchModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self); + friend void QPdfSearchModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfSearchModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self); + friend bool QPdfSearchModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow); + friend void QPdfSearchModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self); + friend void QPdfSearchModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfSearchModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self); + friend void QPdfSearchModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); + friend void QPdfSearchModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self); + friend bool QPdfSearchModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn); + friend void QPdfSearchModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self); + friend void QPdfSearchModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self); + friend void QPdfSearchModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self); + friend void QPdfSearchModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to); + friend void QPdfSearchModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */ from, struct miqt_array /* of QModelIndex* */ to); + friend struct miqt_array /* of QModelIndex* */ QPdfSearchModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self); + friend QObject* QPdfSearchModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QPdfSearchModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QPdfSearchModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QPdfSearchModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QPdfSearchModel* QPdfSearchModel_new() { + return new MiqtVirtualQPdfSearchModel(); +} + +QPdfSearchModel* QPdfSearchModel_new2(QObject* parent) { + return new MiqtVirtualQPdfSearchModel(parent); +} + +void QPdfSearchModel_virtbase(QPdfSearchModel* src, QAbstractListModel** outptr_QAbstractListModel) { + *outptr_QAbstractListModel = static_cast(src); +} + +QMetaObject* QPdfSearchModel_metaObject(const QPdfSearchModel* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QPdfSearchModel_metacast(QPdfSearchModel* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QPdfSearchModel_tr(const char* s) { + QString _ret = QPdfSearchModel::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_array /* of QPdfLink* */ QPdfSearchModel_resultsOnPage(const QPdfSearchModel* self, int page) { + QList _ret = self->resultsOnPage(static_cast(page)); + // Convert QList<> from C++ memory to manually-managed C memory + QPdfLink** _arr = static_cast(malloc(sizeof(QPdfLink*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QPdfLink(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +QPdfLink* QPdfSearchModel_resultAtIndex(const QPdfSearchModel* self, int index) { + return new QPdfLink(self->resultAtIndex(static_cast(index))); +} + +QPdfDocument* QPdfSearchModel_document(const QPdfSearchModel* self) { + return self->document(); +} + +struct miqt_string QPdfSearchModel_searchString(const QPdfSearchModel* self) { + QString _ret = self->searchString(); + // 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_map /* of int to struct miqt_string */ QPdfSearchModel_roleNames(const QPdfSearchModel* self) { + QHash _ret = self->roleNames(); + // Convert QMap<> from C++ memory to manually-managed C memory + int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); + struct miqt_string* _varr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + _karr[_ctr] = _itr->first; + QByteArray _hashval_qb = _itr->second; + struct miqt_string _hashval_ms; + _hashval_ms.len = _hashval_qb.length(); + _hashval_ms.data = static_cast(malloc(_hashval_ms.len)); + memcpy(_hashval_ms.data, _hashval_qb.data(), _hashval_ms.len); + _varr[_ctr] = _hashval_ms; + _ctr++; + } + struct miqt_map _out; + _out.len = _ret.size(); + _out.keys = static_cast(_karr); + _out.values = static_cast(_varr); + return _out; +} + +int QPdfSearchModel_rowCount(const QPdfSearchModel* self, QModelIndex* parent) { + return self->rowCount(*parent); +} + +QVariant* QPdfSearchModel_data(const QPdfSearchModel* self, QModelIndex* index, int role) { + return new QVariant(self->data(*index, static_cast(role))); +} + +void QPdfSearchModel_setSearchString(QPdfSearchModel* self, struct miqt_string searchString) { + QString searchString_QString = QString::fromUtf8(searchString.data, searchString.len); + self->setSearchString(searchString_QString); +} + +void QPdfSearchModel_setDocument(QPdfSearchModel* self, QPdfDocument* document) { + self->setDocument(document); +} + +void QPdfSearchModel_documentChanged(QPdfSearchModel* self) { + self->documentChanged(); +} + +void QPdfSearchModel_connect_documentChanged(QPdfSearchModel* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel::connect(self, static_cast(&QPdfSearchModel::documentChanged), self, [=]() { + miqt_exec_callback_QPdfSearchModel_documentChanged(slot); + }); +} + +void QPdfSearchModel_searchStringChanged(QPdfSearchModel* self) { + self->searchStringChanged(); +} + +void QPdfSearchModel_connect_searchStringChanged(QPdfSearchModel* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel::connect(self, static_cast(&QPdfSearchModel::searchStringChanged), self, [=]() { + miqt_exec_callback_QPdfSearchModel_searchStringChanged(slot); + }); +} + +struct miqt_string QPdfSearchModel_tr2(const char* s, const char* c) { + QString _ret = QPdfSearchModel::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 QPdfSearchModel_tr3(const char* s, const char* c, int n) { + QString _ret = QPdfSearchModel::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; +} + +bool QPdfSearchModel_override_virtual_roleNames(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__roleNames = slot; + return true; +} + +struct miqt_map /* of int to struct miqt_string */ QPdfSearchModel_virtualbase_roleNames(const void* self) { + + QHash _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::roleNames(); + // Convert QMap<> from C++ memory to manually-managed C memory + int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); + struct miqt_string* _varr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + _karr[_ctr] = _itr->first; + QByteArray _hashval_qb = _itr->second; + struct miqt_string _hashval_ms; + _hashval_ms.len = _hashval_qb.length(); + _hashval_ms.data = static_cast(malloc(_hashval_ms.len)); + memcpy(_hashval_ms.data, _hashval_qb.data(), _hashval_ms.len); + _varr[_ctr] = _hashval_ms; + _ctr++; + } + struct miqt_map _out; + _out.len = _ret.size(); + _out.keys = static_cast(_karr); + _out.values = static_cast(_varr); + return _out; + +} + +bool QPdfSearchModel_override_virtual_rowCount(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__rowCount = slot; + return true; +} + +int QPdfSearchModel_virtualbase_rowCount(const void* self, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::rowCount(*parent); + +} + +bool QPdfSearchModel_override_virtual_data(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__data = slot; + return true; +} + +QVariant* QPdfSearchModel_virtualbase_data(const void* self, QModelIndex* index, int role) { + + return new QVariant(( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::data(*index, static_cast(role))); + +} + +bool QPdfSearchModel_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QPdfSearchModel_virtualbase_timerEvent(void* self, QTimerEvent* event) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::timerEvent(event); + +} + +bool QPdfSearchModel_override_virtual_index(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__index = slot; + return true; +} + +QModelIndex* QPdfSearchModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent) { + + return new QModelIndex(( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::index(static_cast(row), static_cast(column), *parent)); + +} + +bool QPdfSearchModel_override_virtual_sibling(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__sibling = slot; + return true; +} + +QModelIndex* QPdfSearchModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx) { + + return new QModelIndex(( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::sibling(static_cast(row), static_cast(column), *idx)); + +} + +bool QPdfSearchModel_override_virtual_dropMimeData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__dropMimeData = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::dropMimeData(data, static_cast(action), static_cast(row), static_cast(column), *parent); + +} + +bool QPdfSearchModel_override_virtual_flags(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__flags = slot; + return true; +} + +int QPdfSearchModel_virtualbase_flags(const void* self, QModelIndex* index) { + + Qt::ItemFlags _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::flags(*index); + return static_cast(_ret); + +} + +bool QPdfSearchModel_override_virtual_setData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setData = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::setData(*index, *value, static_cast(role)); + +} + +bool QPdfSearchModel_override_virtual_headerData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__headerData = slot; + return true; +} + +QVariant* QPdfSearchModel_virtualbase_headerData(const void* self, int section, int orientation, int role) { + + return new QVariant(( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::headerData(static_cast(section), static_cast(orientation), static_cast(role))); + +} + +bool QPdfSearchModel_override_virtual_setHeaderData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setHeaderData = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::setHeaderData(static_cast(section), static_cast(orientation), *value, static_cast(role)); + +} + +bool QPdfSearchModel_override_virtual_itemData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__itemData = slot; + return true; +} + +struct miqt_map /* of int to QVariant* */ QPdfSearchModel_virtualbase_itemData(const void* self, QModelIndex* index) { + + QMap _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::itemData(*index); + // Convert QMap<> from C++ memory to manually-managed C memory + int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); + QVariant** _varr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + _karr[_ctr] = _itr->first; + _varr[_ctr] = new QVariant(_itr->second); + _ctr++; + } + struct miqt_map _out; + _out.len = _ret.size(); + _out.keys = static_cast(_karr); + _out.values = static_cast(_varr); + return _out; + +} + +bool QPdfSearchModel_override_virtual_setItemData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setItemData = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */ roles) { + QMap roles_QMap; + int* roles_karr = static_cast(roles.keys); + QVariant** roles_varr = static_cast(roles.values); + for(size_t i = 0; i < roles.len; ++i) { + roles_QMap[static_cast(roles_karr[i])] = *(roles_varr[i]); + } + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::setItemData(*index, roles_QMap); + +} + +bool QPdfSearchModel_override_virtual_clearItemData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__clearItemData = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_clearItemData(void* self, QModelIndex* index) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::clearItemData(*index); + +} + +bool QPdfSearchModel_override_virtual_mimeTypes(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mimeTypes = slot; + return true; +} + +struct miqt_array /* of struct miqt_string */ QPdfSearchModel_virtualbase_mimeTypes(const void* self) { + + QStringList _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::mimeTypes(); + // Convert QList<> from C++ memory to manually-managed C memory + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QString _lv_ret = _ret[i]; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _lv_b = _lv_ret.toUtf8(); + struct miqt_string _lv_ms; + _lv_ms.len = _lv_b.length(); + _lv_ms.data = static_cast(malloc(_lv_ms.len)); + memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len); + _arr[i] = _lv_ms; + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; + +} + +bool QPdfSearchModel_override_virtual_mimeData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mimeData = slot; + return true; +} + +QMimeData* QPdfSearchModel_virtualbase_mimeData(const void* 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])); + } + + return ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::mimeData(indexes_QList); + +} + +bool QPdfSearchModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__canDropMimeData = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::canDropMimeData(data, static_cast(action), static_cast(row), static_cast(column), *parent); + +} + +bool QPdfSearchModel_override_virtual_supportedDropActions(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__supportedDropActions = slot; + return true; +} + +int QPdfSearchModel_virtualbase_supportedDropActions(const void* self) { + + Qt::DropActions _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::supportedDropActions(); + return static_cast(_ret); + +} + +bool QPdfSearchModel_override_virtual_supportedDragActions(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__supportedDragActions = slot; + return true; +} + +int QPdfSearchModel_virtualbase_supportedDragActions(const void* self) { + + Qt::DropActions _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::supportedDragActions(); + return static_cast(_ret); + +} + +bool QPdfSearchModel_override_virtual_insertRows(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__insertRows = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::insertRows(static_cast(row), static_cast(count), *parent); + +} + +bool QPdfSearchModel_override_virtual_insertColumns(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__insertColumns = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::insertColumns(static_cast(column), static_cast(count), *parent); + +} + +bool QPdfSearchModel_override_virtual_removeRows(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__removeRows = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::removeRows(static_cast(row), static_cast(count), *parent); + +} + +bool QPdfSearchModel_override_virtual_removeColumns(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__removeColumns = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::removeColumns(static_cast(column), static_cast(count), *parent); + +} + +bool QPdfSearchModel_override_virtual_moveRows(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__moveRows = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::moveRows(*sourceParent, static_cast(sourceRow), static_cast(count), *destinationParent, static_cast(destinationChild)); + +} + +bool QPdfSearchModel_override_virtual_moveColumns(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__moveColumns = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::moveColumns(*sourceParent, static_cast(sourceColumn), static_cast(count), *destinationParent, static_cast(destinationChild)); + +} + +bool QPdfSearchModel_override_virtual_fetchMore(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__fetchMore = slot; + return true; +} + +void QPdfSearchModel_virtualbase_fetchMore(void* self, QModelIndex* parent) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::fetchMore(*parent); + +} + +bool QPdfSearchModel_override_virtual_canFetchMore(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__canFetchMore = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent) { + + return ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::canFetchMore(*parent); + +} + +bool QPdfSearchModel_override_virtual_sort(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__sort = slot; + return true; +} + +void QPdfSearchModel_virtualbase_sort(void* self, int column, int order) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::sort(static_cast(column), static_cast(order)); + +} + +bool QPdfSearchModel_override_virtual_buddy(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__buddy = slot; + return true; +} + +QModelIndex* QPdfSearchModel_virtualbase_buddy(const void* self, QModelIndex* index) { + + return new QModelIndex(( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::buddy(*index)); + +} + +bool QPdfSearchModel_override_virtual_match(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__match = slot; + return true; +} + +struct miqt_array /* of QModelIndex* */ QPdfSearchModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { + + QModelIndexList _ret = ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + // 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; + +} + +bool QPdfSearchModel_override_virtual_span(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__span = slot; + return true; +} + +QSize* QPdfSearchModel_virtualbase_span(const void* self, QModelIndex* index) { + + return new QSize(( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::span(*index)); + +} + +bool QPdfSearchModel_override_virtual_multiData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__multiData = slot; + return true; +} + +void QPdfSearchModel_virtualbase_multiData(const void* self, QModelIndex* index, QModelRoleDataSpan* roleDataSpan) { + + ( (const MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::multiData(*index, *roleDataSpan); + +} + +bool QPdfSearchModel_override_virtual_submit(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__submit = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_submit(void* self) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::submit(); + +} + +bool QPdfSearchModel_override_virtual_revert(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__revert = slot; + return true; +} + +void QPdfSearchModel_virtualbase_revert(void* self) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::revert(); + +} + +bool QPdfSearchModel_override_virtual_resetInternalData(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__resetInternalData = slot; + return true; +} + +void QPdfSearchModel_virtualbase_resetInternalData(void* self) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::resetInternalData(); + +} + +bool QPdfSearchModel_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_event(void* self, QEvent* event) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::event(event); + +} + +bool QPdfSearchModel_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QPdfSearchModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + + return ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::eventFilter(watched, event); + +} + +bool QPdfSearchModel_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QPdfSearchModel_virtualbase_childEvent(void* self, QChildEvent* event) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::childEvent(event); + +} + +bool QPdfSearchModel_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QPdfSearchModel_virtualbase_customEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::customEvent(event); + +} + +bool QPdfSearchModel_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QPdfSearchModel_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::connectNotify(*signal); + +} + +bool QPdfSearchModel_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QPdfSearchModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfSearchModel*)(self) )->QPdfSearchModel::disconnectNotify(*signal); + +} + +void QPdfSearchModel_protectedbase_updatePage(bool* _dynamic_cast_ok, void* self, int page) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->updatePage(static_cast(page)); + +} + +QModelIndex* QPdfSearchModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return new QModelIndex(self_cast->createIndex(static_cast(row), static_cast(column))); + +} + +void QPdfSearchModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */ indexes, QDataStream* stream) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + 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_cast->encodeData(indexes_QList, *stream); + +} + +bool QPdfSearchModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->decodeData(static_cast(row), static_cast(column), *parent, *stream); + +} + +void QPdfSearchModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginInsertRows(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfSearchModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endInsertRows(); + +} + +void QPdfSearchModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginRemoveRows(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfSearchModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endRemoveRows(); + +} + +bool QPdfSearchModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->beginMoveRows(*sourceParent, static_cast(sourceFirst), static_cast(sourceLast), *destinationParent, static_cast(destinationRow)); + +} + +void QPdfSearchModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endMoveRows(); + +} + +void QPdfSearchModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginInsertColumns(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfSearchModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endInsertColumns(); + +} + +void QPdfSearchModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginRemoveColumns(*parent, static_cast(first), static_cast(last)); + +} + +void QPdfSearchModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endRemoveColumns(); + +} + +bool QPdfSearchModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->beginMoveColumns(*sourceParent, static_cast(sourceFirst), static_cast(sourceLast), *destinationParent, static_cast(destinationColumn)); + +} + +void QPdfSearchModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endMoveColumns(); + +} + +void QPdfSearchModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->beginResetModel(); + +} + +void QPdfSearchModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->endResetModel(); + +} + +void QPdfSearchModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->changePersistentIndex(*from, *to); + +} + +void QPdfSearchModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */ from, struct miqt_array /* of QModelIndex* */ to) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + QModelIndexList from_QList; + from_QList.reserve(from.len); + QModelIndex** from_arr = static_cast(from.data); + for(size_t i = 0; i < from.len; ++i) { + from_QList.push_back(*(from_arr[i])); + } + QModelIndexList to_QList; + to_QList.reserve(to.len); + QModelIndex** to_arr = static_cast(to.data); + for(size_t i = 0; i < to.len; ++i) { + to_QList.push_back(*(to_arr[i])); + } + + self_cast->changePersistentIndexList(from_QList, to_QList); + +} + +struct miqt_array /* of QModelIndex* */ QPdfSearchModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return (struct miqt_array){}; + } + + *_dynamic_cast_ok = true; + + QModelIndexList _ret = self_cast->persistentIndexList(); + // 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; + +} + +QObject* QPdfSearchModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return self_cast->sender(); + +} + +int QPdfSearchModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->senderSignalIndex(); + +} + +int QPdfSearchModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->receivers(signal); + +} + +bool QPdfSearchModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQPdfSearchModel* self_cast = dynamic_cast( (QPdfSearchModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->isSignalConnected(*signal); + +} + +void QPdfSearchModel_delete(QPdfSearchModel* self) { + delete self; +} + diff --git a/qt6/pdf/gen_qpdfsearchmodel.go b/qt6/pdf/gen_qpdfsearchmodel.go new file mode 100644 index 00000000..3331e961 --- /dev/null +++ b/qt6/pdf/gen_qpdfsearchmodel.go @@ -0,0 +1,1927 @@ +package pdf + +/* + +#include "gen_qpdfsearchmodel.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QPdfSearchModel__Role int + +const ( + QPdfSearchModel__Page QPdfSearchModel__Role = 256 + QPdfSearchModel__IndexOnPage QPdfSearchModel__Role = 257 + QPdfSearchModel__Location QPdfSearchModel__Role = 258 + QPdfSearchModel__ContextBefore QPdfSearchModel__Role = 259 + QPdfSearchModel__ContextAfter QPdfSearchModel__Role = 260 + QPdfSearchModel__NRoles QPdfSearchModel__Role = 261 +) + +type QPdfSearchModel struct { + h *C.QPdfSearchModel + *qt6.QAbstractListModel +} + +func (this *QPdfSearchModel) cPointer() *C.QPdfSearchModel { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfSearchModel) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfSearchModel constructs the type using only CGO pointers. +func newQPdfSearchModel(h *C.QPdfSearchModel) *QPdfSearchModel { + if h == nil { + return nil + } + var outptr_QAbstractListModel *C.QAbstractListModel = nil + C.QPdfSearchModel_virtbase(h, &outptr_QAbstractListModel) + + return &QPdfSearchModel{h: h, + QAbstractListModel: qt6.UnsafeNewQAbstractListModel(unsafe.Pointer(outptr_QAbstractListModel))} +} + +// UnsafeNewQPdfSearchModel constructs the type using only unsafe pointers. +func UnsafeNewQPdfSearchModel(h unsafe.Pointer) *QPdfSearchModel { + return newQPdfSearchModel((*C.QPdfSearchModel)(h)) +} + +// NewQPdfSearchModel constructs a new QPdfSearchModel object. +func NewQPdfSearchModel() *QPdfSearchModel { + + return newQPdfSearchModel(C.QPdfSearchModel_new()) +} + +// NewQPdfSearchModel2 constructs a new QPdfSearchModel object. +func NewQPdfSearchModel2(parent *qt6.QObject) *QPdfSearchModel { + + return newQPdfSearchModel(C.QPdfSearchModel_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QPdfSearchModel) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QPdfSearchModel_metaObject(this.h))) +} + +func (this *QPdfSearchModel) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QPdfSearchModel_metacast(this.h, param1_Cstring)) +} + +func QPdfSearchModel_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfSearchModel_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfSearchModel) ResultsOnPage(page int) []QPdfLink { + var _ma C.struct_miqt_array = C.QPdfSearchModel_resultsOnPage(this.h, (C.int)(page)) + _ret := make([]QPdfLink, int(_ma.len)) + _outCast := (*[0xffff]*C.QPdfLink)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := newQPdfLink(_outCast[i]) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret +} + +func (this *QPdfSearchModel) ResultAtIndex(index int) *QPdfLink { + _goptr := newQPdfLink(C.QPdfSearchModel_resultAtIndex(this.h, (C.int)(index))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfSearchModel) Document() *QPdfDocument { + return newQPdfDocument(C.QPdfSearchModel_document(this.h)) +} + +func (this *QPdfSearchModel) SearchString() string { + var _ms C.struct_miqt_string = C.QPdfSearchModel_searchString(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfSearchModel) RoleNames() map[int][]byte { + var _mm C.struct_miqt_map = C.QPdfSearchModel_roleNames(this.h) + _ret := make(map[int][]byte, int(_mm.len)) + _Keys := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + _entry_Key := (int)(_Keys[i]) + + var _hashval_bytearray C.struct_miqt_string = _Values[i] + _hashval_ret := C.GoBytes(unsafe.Pointer(_hashval_bytearray.data), C.int(int64(_hashval_bytearray.len))) + C.free(unsafe.Pointer(_hashval_bytearray.data)) + _entry_Value := _hashval_ret + _ret[_entry_Key] = _entry_Value + } + return _ret +} + +func (this *QPdfSearchModel) RowCount(parent *qt6.QModelIndex) int { + return (int)(C.QPdfSearchModel_rowCount(this.h, (*C.QModelIndex)(parent.UnsafePointer()))) +} + +func (this *QPdfSearchModel) Data(index *qt6.QModelIndex, role int) *qt6.QVariant { + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QPdfSearchModel_data(this.h, (*C.QModelIndex)(index.UnsafePointer()), (C.int)(role)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfSearchModel) SetSearchString(searchString string) { + searchString_ms := C.struct_miqt_string{} + searchString_ms.data = C.CString(searchString) + searchString_ms.len = C.size_t(len(searchString)) + defer C.free(unsafe.Pointer(searchString_ms.data)) + C.QPdfSearchModel_setSearchString(this.h, searchString_ms) +} + +func (this *QPdfSearchModel) SetDocument(document *QPdfDocument) { + C.QPdfSearchModel_setDocument(this.h, document.cPointer()) +} + +func (this *QPdfSearchModel) DocumentChanged() { + C.QPdfSearchModel_documentChanged(this.h) +} +func (this *QPdfSearchModel) OnDocumentChanged(slot func()) { + C.QPdfSearchModel_connect_documentChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfSearchModel_documentChanged +func miqt_exec_callback_QPdfSearchModel_documentChanged(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func (this *QPdfSearchModel) SearchStringChanged() { + C.QPdfSearchModel_searchStringChanged(this.h) +} +func (this *QPdfSearchModel) OnSearchStringChanged(slot func()) { + C.QPdfSearchModel_connect_searchStringChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfSearchModel_searchStringChanged +func miqt_exec_callback_QPdfSearchModel_searchStringChanged(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func QPdfSearchModel_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfSearchModel_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfSearchModel_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfSearchModel_tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +// UpdatePage can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) UpdatePage(page int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_updatePage(&_dynamic_cast_ok, unsafe.Pointer(this.h), (C.int)(page)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// CreateIndex can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) CreateIndex(row int, column int) qt6.QModelIndex { + + var _dynamic_cast_ok C.bool = false + _goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfSearchModel_protectedbase_createIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h), (C.int)(row), (C.int)(column)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _method_ret := *_goptr + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// EncodeData can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EncodeData(indexes []qt6.QModelIndex, stream *qt6.QDataStream) { + indexes_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(indexes)))) + defer C.free(unsafe.Pointer(indexes_CArray)) + for i := range indexes { + indexes_CArray[i] = (*C.QModelIndex)(indexes[i].UnsafePointer()) + } + indexes_ma := C.struct_miqt_array{len: C.size_t(len(indexes)), data: unsafe.Pointer(indexes_CArray)} + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_encodeData(&_dynamic_cast_ok, unsafe.Pointer(this.h), indexes_ma, (*C.QDataStream)(stream.UnsafePointer())) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// DecodeData can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) DecodeData(row int, column int, parent *qt6.QModelIndex, stream *qt6.QDataStream) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfSearchModel_protectedbase_decodeData(&_dynamic_cast_ok, unsafe.Pointer(this.h), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer()), (*C.QDataStream)(stream.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// BeginInsertRows can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginInsertRows(parent *qt6.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_beginInsertRows(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndInsertRows can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndInsertRows() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endInsertRows(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginRemoveRows can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginRemoveRows(parent *qt6.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_beginRemoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndRemoveRows can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndRemoveRows() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endRemoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginMoveRows can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginMoveRows(sourceParent *qt6.QModelIndex, sourceFirst int, sourceLast int, destinationParent *qt6.QModelIndex, destinationRow int) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfSearchModel_protectedbase_beginMoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceFirst), (C.int)(sourceLast), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationRow))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// EndMoveRows can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndMoveRows() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endMoveRows(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginInsertColumns can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginInsertColumns(parent *qt6.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_beginInsertColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndInsertColumns can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndInsertColumns() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endInsertColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginRemoveColumns can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginRemoveColumns(parent *qt6.QModelIndex, first int, last int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_beginRemoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()), (C.int)(first), (C.int)(last)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndRemoveColumns can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndRemoveColumns() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endRemoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginMoveColumns can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginMoveColumns(sourceParent *qt6.QModelIndex, sourceFirst int, sourceLast int, destinationParent *qt6.QModelIndex, destinationColumn int) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfSearchModel_protectedbase_beginMoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceFirst), (C.int)(sourceLast), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationColumn))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// EndMoveColumns can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndMoveColumns() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endMoveColumns(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// BeginResetModel can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) BeginResetModel() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_beginResetModel(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// EndResetModel can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) EndResetModel() { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_endResetModel(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// ChangePersistentIndex can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) ChangePersistentIndex(from *qt6.QModelIndex, to *qt6.QModelIndex) { + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_changePersistentIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QModelIndex)(from.UnsafePointer()), (*C.QModelIndex)(to.UnsafePointer())) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// ChangePersistentIndexList can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) ChangePersistentIndexList(from []qt6.QModelIndex, to []qt6.QModelIndex) { + from_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(from)))) + defer C.free(unsafe.Pointer(from_CArray)) + for i := range from { + from_CArray[i] = (*C.QModelIndex)(from[i].UnsafePointer()) + } + from_ma := C.struct_miqt_array{len: C.size_t(len(from)), data: unsafe.Pointer(from_CArray)} + to_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(to)))) + defer C.free(unsafe.Pointer(to_CArray)) + for i := range to { + to_CArray[i] = (*C.QModelIndex)(to[i].UnsafePointer()) + } + to_ma := C.struct_miqt_array{len: C.size_t(len(to)), data: unsafe.Pointer(to_CArray)} + + var _dynamic_cast_ok C.bool = false + C.QPdfSearchModel_protectedbase_changePersistentIndexList(&_dynamic_cast_ok, unsafe.Pointer(this.h), from_ma, to_ma) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// PersistentIndexList can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) PersistentIndexList() []qt6.QModelIndex { + + var _dynamic_cast_ok C.bool = false + var _ma C.struct_miqt_array = C.QPdfSearchModel_protectedbase_persistentIndexList(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + _ret := make([]qt6.QModelIndex, int(_ma.len)) + _outCast := (*[0xffff]*C.QModelIndex)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(_outCast[i])) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + _method_ret := _ret + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Sender can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QPdfSearchModel_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// SenderSignalIndex can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfSearchModel_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Receivers can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) Receivers(signal string) int { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfSearchModel_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// IsSignalConnected can only be called from a QPdfSearchModel that was directly constructed. +func (this *QPdfSearchModel) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfSearchModel_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +func (this *QPdfSearchModel) callVirtualBase_RoleNames() map[int][]byte { + + var _mm C.struct_miqt_map = C.QPdfSearchModel_virtualbase_roleNames(unsafe.Pointer(this.h)) + _ret := make(map[int][]byte, int(_mm.len)) + _Keys := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + _entry_Key := (int)(_Keys[i]) + + var _hashval_bytearray C.struct_miqt_string = _Values[i] + _hashval_ret := C.GoBytes(unsafe.Pointer(_hashval_bytearray.data), C.int(int64(_hashval_bytearray.len))) + C.free(unsafe.Pointer(_hashval_bytearray.data)) + _entry_Value := _hashval_ret + _ret[_entry_Key] = _entry_Value + } + return _ret + +} +func (this *QPdfSearchModel) OnRoleNames(slot func(super func() map[int][]byte) map[int][]byte) { + ok := C.QPdfSearchModel_override_virtual_roleNames(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_roleNames +func miqt_exec_callback_QPdfSearchModel_roleNames(self *C.QPdfSearchModel, cb C.intptr_t) C.struct_miqt_map { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() map[int][]byte) map[int][]byte) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_RoleNames) + virtualReturn_Keys_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Keys_CArray)) + virtualReturn_Values_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Values_CArray)) + virtualReturn_ctr := 0 + for virtualReturn_k, virtualReturn_v := range virtualReturn { + virtualReturn_Keys_CArray[virtualReturn_ctr] = (C.int)(virtualReturn_k) + virtualReturn_v_alias := C.struct_miqt_string{} + if len(virtualReturn_v) > 0 { + virtualReturn_v_alias.data = (*C.char)(unsafe.Pointer(&virtualReturn_v[0])) + } else { + virtualReturn_v_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + virtualReturn_v_alias.len = C.size_t(len(virtualReturn_v)) + virtualReturn_Values_CArray[virtualReturn_ctr] = virtualReturn_v_alias + virtualReturn_ctr++ + } + virtualReturn_mm := C.struct_miqt_map{ + len: C.size_t(len(virtualReturn)), + keys: unsafe.Pointer(virtualReturn_Keys_CArray), + values: unsafe.Pointer(virtualReturn_Values_CArray), + } + + return virtualReturn_mm + +} + +func (this *QPdfSearchModel) callVirtualBase_RowCount(parent *qt6.QModelIndex) int { + + return (int)(C.QPdfSearchModel_virtualbase_rowCount(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnRowCount(slot func(super func(parent *qt6.QModelIndex) int, parent *qt6.QModelIndex) int) { + ok := C.QPdfSearchModel_override_virtual_rowCount(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_rowCount +func miqt_exec_callback_QPdfSearchModel_rowCount(self *C.QPdfSearchModel, cb C.intptr_t, parent *C.QModelIndex) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt6.QModelIndex) int, parent *qt6.QModelIndex) int) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_RowCount, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_Data(index *qt6.QModelIndex, role int) *qt6.QVariant { + + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QPdfSearchModel_virtualbase_data(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), (C.int)(role)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfSearchModel) OnData(slot func(super func(index *qt6.QModelIndex, role int) *qt6.QVariant, index *qt6.QModelIndex, role int) *qt6.QVariant) { + ok := C.QPdfSearchModel_override_virtual_data(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_data +func miqt_exec_callback_QPdfSearchModel_data(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex, role C.int) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex, role int) *qt6.QVariant, index *qt6.QModelIndex, role int) *qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + slotval2 := (int)(role) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Data, slotval1, slotval2) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QPdfSearchModel_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QPdfSearchModel_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_timerEvent +func miqt_exec_callback_QPdfSearchModel_timerEvent(self *C.QPdfSearchModel, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QPdfSearchModel) callVirtualBase_Index(row int, column int, parent *qt6.QModelIndex) *qt6.QModelIndex { + + _goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfSearchModel_virtualbase_index(unsafe.Pointer(this.h), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfSearchModel) OnIndex(slot func(super func(row int, column int, parent *qt6.QModelIndex) *qt6.QModelIndex, row int, column int, parent *qt6.QModelIndex) *qt6.QModelIndex) { + ok := C.QPdfSearchModel_override_virtual_index(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_index +func miqt_exec_callback_QPdfSearchModel_index(self *C.QPdfSearchModel, cb C.intptr_t, row C.int, column C.int, parent *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, column int, parent *qt6.QModelIndex) *qt6.QModelIndex, row int, column int, parent *qt6.QModelIndex) *qt6.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(column) + + slotval3 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Index, slotval1, slotval2, slotval3) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_Sibling(row int, column int, idx *qt6.QModelIndex) *qt6.QModelIndex { + + _goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfSearchModel_virtualbase_sibling(unsafe.Pointer(this.h), (C.int)(row), (C.int)(column), (*C.QModelIndex)(idx.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfSearchModel) OnSibling(slot func(super func(row int, column int, idx *qt6.QModelIndex) *qt6.QModelIndex, row int, column int, idx *qt6.QModelIndex) *qt6.QModelIndex) { + ok := C.QPdfSearchModel_override_virtual_sibling(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_sibling +func miqt_exec_callback_QPdfSearchModel_sibling(self *C.QPdfSearchModel, cb C.intptr_t, row C.int, column C.int, idx *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, column int, idx *qt6.QModelIndex) *qt6.QModelIndex, row int, column int, idx *qt6.QModelIndex) *qt6.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(column) + + slotval3 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(idx)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Sibling, slotval1, slotval2, slotval3) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_DropMimeData(data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_dropMimeData(unsafe.Pointer(this.h), (*C.QMimeData)(data.UnsafePointer()), (C.int)(action), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnDropMimeData(slot func(super func(data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool, data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_dropMimeData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_dropMimeData +func miqt_exec_callback_QPdfSearchModel_dropMimeData(self *C.QPdfSearchModel, cb C.intptr_t, data *C.QMimeData, action C.int, row C.int, column C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool, data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMimeData(unsafe.Pointer(data)) + + slotval2 := (qt6.DropAction)(action) + + slotval3 := (int)(row) + + slotval4 := (int)(column) + + slotval5 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_DropMimeData, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_Flags(index *qt6.QModelIndex) qt6.ItemFlag { + + return (qt6.ItemFlag)(C.QPdfSearchModel_virtualbase_flags(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnFlags(slot func(super func(index *qt6.QModelIndex) qt6.ItemFlag, index *qt6.QModelIndex) qt6.ItemFlag) { + ok := C.QPdfSearchModel_override_virtual_flags(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_flags +func miqt_exec_callback_QPdfSearchModel_flags(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex) qt6.ItemFlag, index *qt6.QModelIndex) qt6.ItemFlag) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Flags, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_SetData(index *qt6.QModelIndex, value *qt6.QVariant, role int) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_setData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), (*C.QVariant)(value.UnsafePointer()), (C.int)(role))) + +} +func (this *QPdfSearchModel) OnSetData(slot func(super func(index *qt6.QModelIndex, value *qt6.QVariant, role int) bool, index *qt6.QModelIndex, value *qt6.QVariant, role int) bool) { + ok := C.QPdfSearchModel_override_virtual_setData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_setData +func miqt_exec_callback_QPdfSearchModel_setData(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex, value *C.QVariant, role C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex, value *qt6.QVariant, role int) bool, index *qt6.QModelIndex, value *qt6.QVariant, role int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + slotval2 := qt6.UnsafeNewQVariant(unsafe.Pointer(value)) + + slotval3 := (int)(role) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_SetData, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_HeaderData(section int, orientation qt6.Orientation, role int) *qt6.QVariant { + + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QPdfSearchModel_virtualbase_headerData(unsafe.Pointer(this.h), (C.int)(section), (C.int)(orientation), (C.int)(role)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfSearchModel) OnHeaderData(slot func(super func(section int, orientation qt6.Orientation, role int) *qt6.QVariant, section int, orientation qt6.Orientation, role int) *qt6.QVariant) { + ok := C.QPdfSearchModel_override_virtual_headerData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_headerData +func miqt_exec_callback_QPdfSearchModel_headerData(self *C.QPdfSearchModel, cb C.intptr_t, section C.int, orientation C.int, role C.int) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(section int, orientation qt6.Orientation, role int) *qt6.QVariant, section int, orientation qt6.Orientation, role int) *qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(section) + + slotval2 := (qt6.Orientation)(orientation) + + slotval3 := (int)(role) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_HeaderData, slotval1, slotval2, slotval3) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_SetHeaderData(section int, orientation qt6.Orientation, value *qt6.QVariant, role int) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_setHeaderData(unsafe.Pointer(this.h), (C.int)(section), (C.int)(orientation), (*C.QVariant)(value.UnsafePointer()), (C.int)(role))) + +} +func (this *QPdfSearchModel) OnSetHeaderData(slot func(super func(section int, orientation qt6.Orientation, value *qt6.QVariant, role int) bool, section int, orientation qt6.Orientation, value *qt6.QVariant, role int) bool) { + ok := C.QPdfSearchModel_override_virtual_setHeaderData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_setHeaderData +func miqt_exec_callback_QPdfSearchModel_setHeaderData(self *C.QPdfSearchModel, cb C.intptr_t, section C.int, orientation C.int, value *C.QVariant, role C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(section int, orientation qt6.Orientation, value *qt6.QVariant, role int) bool, section int, orientation qt6.Orientation, value *qt6.QVariant, role int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(section) + + slotval2 := (qt6.Orientation)(orientation) + + slotval3 := qt6.UnsafeNewQVariant(unsafe.Pointer(value)) + + slotval4 := (int)(role) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_SetHeaderData, slotval1, slotval2, slotval3, slotval4) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_ItemData(index *qt6.QModelIndex) map[int]qt6.QVariant { + + var _mm C.struct_miqt_map = C.QPdfSearchModel_virtualbase_itemData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())) + _ret := make(map[int]qt6.QVariant, int(_mm.len)) + _Keys := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + _entry_Key := (int)(_Keys[i]) + + _mapval_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(_Values[i])) + _mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _entry_Value := *_mapval_goptr + + _ret[_entry_Key] = _entry_Value + } + return _ret + +} +func (this *QPdfSearchModel) OnItemData(slot func(super func(index *qt6.QModelIndex) map[int]qt6.QVariant, index *qt6.QModelIndex) map[int]qt6.QVariant) { + ok := C.QPdfSearchModel_override_virtual_itemData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_itemData +func miqt_exec_callback_QPdfSearchModel_itemData(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex) C.struct_miqt_map { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex) map[int]qt6.QVariant, index *qt6.QModelIndex) map[int]qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_ItemData, slotval1) + virtualReturn_Keys_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Keys_CArray)) + virtualReturn_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_Values_CArray)) + virtualReturn_ctr := 0 + for virtualReturn_k, virtualReturn_v := range virtualReturn { + virtualReturn_Keys_CArray[virtualReturn_ctr] = (C.int)(virtualReturn_k) + virtualReturn_Values_CArray[virtualReturn_ctr] = (*C.QVariant)(virtualReturn_v.UnsafePointer()) + virtualReturn_ctr++ + } + virtualReturn_mm := C.struct_miqt_map{ + len: C.size_t(len(virtualReturn)), + keys: unsafe.Pointer(virtualReturn_Keys_CArray), + values: unsafe.Pointer(virtualReturn_Values_CArray), + } + + return virtualReturn_mm + +} + +func (this *QPdfSearchModel) callVirtualBase_SetItemData(index *qt6.QModelIndex, roles map[int]qt6.QVariant) bool { + roles_Keys_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(roles)))) + defer C.free(unsafe.Pointer(roles_Keys_CArray)) + roles_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(roles)))) + defer C.free(unsafe.Pointer(roles_Values_CArray)) + roles_ctr := 0 + for roles_k, roles_v := range roles { + roles_Keys_CArray[roles_ctr] = (C.int)(roles_k) + roles_Values_CArray[roles_ctr] = (*C.QVariant)(roles_v.UnsafePointer()) + roles_ctr++ + } + roles_mm := C.struct_miqt_map{ + len: C.size_t(len(roles)), + keys: unsafe.Pointer(roles_Keys_CArray), + values: unsafe.Pointer(roles_Values_CArray), + } + + return (bool)(C.QPdfSearchModel_virtualbase_setItemData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), roles_mm)) + +} +func (this *QPdfSearchModel) OnSetItemData(slot func(super func(index *qt6.QModelIndex, roles map[int]qt6.QVariant) bool, index *qt6.QModelIndex, roles map[int]qt6.QVariant) bool) { + ok := C.QPdfSearchModel_override_virtual_setItemData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_setItemData +func miqt_exec_callback_QPdfSearchModel_setItemData(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex, roles C.struct_miqt_map) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex, roles map[int]qt6.QVariant) bool, index *qt6.QModelIndex, roles map[int]qt6.QVariant) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + var roles_mm C.struct_miqt_map = roles + roles_ret := make(map[int]qt6.QVariant, int(roles_mm.len)) + roles_Keys := (*[0xffff]C.int)(unsafe.Pointer(roles_mm.keys)) + roles_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(roles_mm.values)) + for i := 0; i < int(roles_mm.len); i++ { + roles_entry_Key := (int)(roles_Keys[i]) + + roles_mapval_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(roles_Values[i])) + roles_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + roles_entry_Value := *roles_mapval_goptr + + roles_ret[roles_entry_Key] = roles_entry_Value + } + slotval2 := roles_ret + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_SetItemData, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_ClearItemData(index *qt6.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_clearItemData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnClearItemData(slot func(super func(index *qt6.QModelIndex) bool, index *qt6.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_clearItemData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_clearItemData +func miqt_exec_callback_QPdfSearchModel_clearItemData(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex) bool, index *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_ClearItemData, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_MimeTypes() []string { + + var _ma C.struct_miqt_array = C.QPdfSearchModel_virtualbase_mimeTypes(unsafe.Pointer(this.h)) + _ret := make([]string, int(_ma.len)) + _outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + var _lv_ms C.struct_miqt_string = _outCast[i] + _lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len))) + C.free(unsafe.Pointer(_lv_ms.data)) + _ret[i] = _lv_ret + } + return _ret + +} +func (this *QPdfSearchModel) OnMimeTypes(slot func(super func() []string) []string) { + ok := C.QPdfSearchModel_override_virtual_mimeTypes(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_mimeTypes +func miqt_exec_callback_QPdfSearchModel_mimeTypes(self *C.QPdfSearchModel, cb C.intptr_t) C.struct_miqt_array { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() []string) []string) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_MimeTypes) + virtualReturn_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_CArray)) + for i := range virtualReturn { + virtualReturn_i_ms := C.struct_miqt_string{} + virtualReturn_i_ms.data = C.CString(virtualReturn[i]) + virtualReturn_i_ms.len = C.size_t(len(virtualReturn[i])) + defer C.free(unsafe.Pointer(virtualReturn_i_ms.data)) + virtualReturn_CArray[i] = virtualReturn_i_ms + } + virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)} + + return virtualReturn_ma + +} + +func (this *QPdfSearchModel) callVirtualBase_MimeData(indexes []qt6.QModelIndex) *qt6.QMimeData { + indexes_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(indexes)))) + defer C.free(unsafe.Pointer(indexes_CArray)) + for i := range indexes { + indexes_CArray[i] = (*C.QModelIndex)(indexes[i].UnsafePointer()) + } + indexes_ma := C.struct_miqt_array{len: C.size_t(len(indexes)), data: unsafe.Pointer(indexes_CArray)} + + return qt6.UnsafeNewQMimeData(unsafe.Pointer(C.QPdfSearchModel_virtualbase_mimeData(unsafe.Pointer(this.h), indexes_ma))) + +} +func (this *QPdfSearchModel) OnMimeData(slot func(super func(indexes []qt6.QModelIndex) *qt6.QMimeData, indexes []qt6.QModelIndex) *qt6.QMimeData) { + ok := C.QPdfSearchModel_override_virtual_mimeData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_mimeData +func miqt_exec_callback_QPdfSearchModel_mimeData(self *C.QPdfSearchModel, cb C.intptr_t, indexes C.struct_miqt_array) *C.QMimeData { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(indexes []qt6.QModelIndex) *qt6.QMimeData, indexes []qt6.QModelIndex) *qt6.QMimeData) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var indexes_ma C.struct_miqt_array = indexes + indexes_ret := make([]qt6.QModelIndex, int(indexes_ma.len)) + indexes_outCast := (*[0xffff]*C.QModelIndex)(unsafe.Pointer(indexes_ma.data)) // hey ya + for i := 0; i < int(indexes_ma.len); i++ { + indexes_lv_goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(indexes_outCast[i])) + indexes_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + indexes_ret[i] = *indexes_lv_goptr + } + slotval1 := indexes_ret + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_MimeData, slotval1) + + return (*C.QMimeData)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_CanDropMimeData(data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_canDropMimeData(unsafe.Pointer(this.h), (*C.QMimeData)(data.UnsafePointer()), (C.int)(action), (C.int)(row), (C.int)(column), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnCanDropMimeData(slot func(super func(data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool, data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_canDropMimeData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_canDropMimeData +func miqt_exec_callback_QPdfSearchModel_canDropMimeData(self *C.QPdfSearchModel, cb C.intptr_t, data *C.QMimeData, action C.int, row C.int, column C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool, data *qt6.QMimeData, action qt6.DropAction, row int, column int, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMimeData(unsafe.Pointer(data)) + + slotval2 := (qt6.DropAction)(action) + + slotval3 := (int)(row) + + slotval4 := (int)(column) + + slotval5 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_CanDropMimeData, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_SupportedDropActions() qt6.DropAction { + + return (qt6.DropAction)(C.QPdfSearchModel_virtualbase_supportedDropActions(unsafe.Pointer(this.h))) + +} +func (this *QPdfSearchModel) OnSupportedDropActions(slot func(super func() qt6.DropAction) qt6.DropAction) { + ok := C.QPdfSearchModel_override_virtual_supportedDropActions(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_supportedDropActions +func miqt_exec_callback_QPdfSearchModel_supportedDropActions(self *C.QPdfSearchModel, cb C.intptr_t) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() qt6.DropAction) qt6.DropAction) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_SupportedDropActions) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_SupportedDragActions() qt6.DropAction { + + return (qt6.DropAction)(C.QPdfSearchModel_virtualbase_supportedDragActions(unsafe.Pointer(this.h))) + +} +func (this *QPdfSearchModel) OnSupportedDragActions(slot func(super func() qt6.DropAction) qt6.DropAction) { + ok := C.QPdfSearchModel_override_virtual_supportedDragActions(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_supportedDragActions +func miqt_exec_callback_QPdfSearchModel_supportedDragActions(self *C.QPdfSearchModel, cb C.intptr_t) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() qt6.DropAction) qt6.DropAction) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_SupportedDragActions) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_InsertRows(row int, count int, parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_insertRows(unsafe.Pointer(this.h), (C.int)(row), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnInsertRows(slot func(super func(row int, count int, parent *qt6.QModelIndex) bool, row int, count int, parent *qt6.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_insertRows(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_insertRows +func miqt_exec_callback_QPdfSearchModel_insertRows(self *C.QPdfSearchModel, cb C.intptr_t, row C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, count int, parent *qt6.QModelIndex) bool, row int, count int, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(count) + + slotval3 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_InsertRows, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_InsertColumns(column int, count int, parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_insertColumns(unsafe.Pointer(this.h), (C.int)(column), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnInsertColumns(slot func(super func(column int, count int, parent *qt6.QModelIndex) bool, column int, count int, parent *qt6.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_insertColumns(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_insertColumns +func miqt_exec_callback_QPdfSearchModel_insertColumns(self *C.QPdfSearchModel, cb C.intptr_t, column C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(column int, count int, parent *qt6.QModelIndex) bool, column int, count int, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(column) + + slotval2 := (int)(count) + + slotval3 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_InsertColumns, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_RemoveRows(row int, count int, parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_removeRows(unsafe.Pointer(this.h), (C.int)(row), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnRemoveRows(slot func(super func(row int, count int, parent *qt6.QModelIndex) bool, row int, count int, parent *qt6.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_removeRows(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_removeRows +func miqt_exec_callback_QPdfSearchModel_removeRows(self *C.QPdfSearchModel, cb C.intptr_t, row C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(row int, count int, parent *qt6.QModelIndex) bool, row int, count int, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(row) + + slotval2 := (int)(count) + + slotval3 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_RemoveRows, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_RemoveColumns(column int, count int, parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_removeColumns(unsafe.Pointer(this.h), (C.int)(column), (C.int)(count), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnRemoveColumns(slot func(super func(column int, count int, parent *qt6.QModelIndex) bool, column int, count int, parent *qt6.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_removeColumns(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_removeColumns +func miqt_exec_callback_QPdfSearchModel_removeColumns(self *C.QPdfSearchModel, cb C.intptr_t, column C.int, count C.int, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(column int, count int, parent *qt6.QModelIndex) bool, column int, count int, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(column) + + slotval2 := (int)(count) + + slotval3 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_RemoveColumns, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_MoveRows(sourceParent *qt6.QModelIndex, sourceRow int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_moveRows(unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceRow), (C.int)(count), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationChild))) + +} +func (this *QPdfSearchModel) OnMoveRows(slot func(super func(sourceParent *qt6.QModelIndex, sourceRow int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool, sourceParent *qt6.QModelIndex, sourceRow int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool) { + ok := C.QPdfSearchModel_override_virtual_moveRows(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_moveRows +func miqt_exec_callback_QPdfSearchModel_moveRows(self *C.QPdfSearchModel, cb C.intptr_t, sourceParent *C.QModelIndex, sourceRow C.int, count C.int, destinationParent *C.QModelIndex, destinationChild C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(sourceParent *qt6.QModelIndex, sourceRow int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool, sourceParent *qt6.QModelIndex, sourceRow int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(sourceParent)) + + slotval2 := (int)(sourceRow) + + slotval3 := (int)(count) + + slotval4 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(destinationParent)) + + slotval5 := (int)(destinationChild) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_MoveRows, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_MoveColumns(sourceParent *qt6.QModelIndex, sourceColumn int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_moveColumns(unsafe.Pointer(this.h), (*C.QModelIndex)(sourceParent.UnsafePointer()), (C.int)(sourceColumn), (C.int)(count), (*C.QModelIndex)(destinationParent.UnsafePointer()), (C.int)(destinationChild))) + +} +func (this *QPdfSearchModel) OnMoveColumns(slot func(super func(sourceParent *qt6.QModelIndex, sourceColumn int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool, sourceParent *qt6.QModelIndex, sourceColumn int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool) { + ok := C.QPdfSearchModel_override_virtual_moveColumns(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_moveColumns +func miqt_exec_callback_QPdfSearchModel_moveColumns(self *C.QPdfSearchModel, cb C.intptr_t, sourceParent *C.QModelIndex, sourceColumn C.int, count C.int, destinationParent *C.QModelIndex, destinationChild C.int) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(sourceParent *qt6.QModelIndex, sourceColumn int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool, sourceParent *qt6.QModelIndex, sourceColumn int, count int, destinationParent *qt6.QModelIndex, destinationChild int) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(sourceParent)) + + slotval2 := (int)(sourceColumn) + + slotval3 := (int)(count) + + slotval4 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(destinationParent)) + + slotval5 := (int)(destinationChild) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_MoveColumns, slotval1, slotval2, slotval3, slotval4, slotval5) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_FetchMore(parent *qt6.QModelIndex) { + + C.QPdfSearchModel_virtualbase_fetchMore(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnFetchMore(slot func(super func(parent *qt6.QModelIndex), parent *qt6.QModelIndex)) { + ok := C.QPdfSearchModel_override_virtual_fetchMore(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_fetchMore +func miqt_exec_callback_QPdfSearchModel_fetchMore(self *C.QPdfSearchModel, cb C.intptr_t, parent *C.QModelIndex) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt6.QModelIndex), parent *qt6.QModelIndex)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_FetchMore, slotval1) + +} + +func (this *QPdfSearchModel) callVirtualBase_CanFetchMore(parent *qt6.QModelIndex) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_canFetchMore(unsafe.Pointer(this.h), (*C.QModelIndex)(parent.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnCanFetchMore(slot func(super func(parent *qt6.QModelIndex) bool, parent *qt6.QModelIndex) bool) { + ok := C.QPdfSearchModel_override_virtual_canFetchMore(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_canFetchMore +func miqt_exec_callback_QPdfSearchModel_canFetchMore(self *C.QPdfSearchModel, cb C.intptr_t, parent *C.QModelIndex) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *qt6.QModelIndex) bool, parent *qt6.QModelIndex) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(parent)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_CanFetchMore, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_Sort(column int, order qt6.SortOrder) { + + C.QPdfSearchModel_virtualbase_sort(unsafe.Pointer(this.h), (C.int)(column), (C.int)(order)) + +} +func (this *QPdfSearchModel) OnSort(slot func(super func(column int, order qt6.SortOrder), column int, order qt6.SortOrder)) { + ok := C.QPdfSearchModel_override_virtual_sort(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_sort +func miqt_exec_callback_QPdfSearchModel_sort(self *C.QPdfSearchModel, cb C.intptr_t, column C.int, order C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(column int, order qt6.SortOrder), column int, order qt6.SortOrder)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(column) + + slotval2 := (qt6.SortOrder)(order) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Sort, slotval1, slotval2) + +} + +func (this *QPdfSearchModel) callVirtualBase_Buddy(index *qt6.QModelIndex) *qt6.QModelIndex { + + _goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(C.QPdfSearchModel_virtualbase_buddy(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfSearchModel) OnBuddy(slot func(super func(index *qt6.QModelIndex) *qt6.QModelIndex, index *qt6.QModelIndex) *qt6.QModelIndex) { + ok := C.QPdfSearchModel_override_virtual_buddy(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_buddy +func miqt_exec_callback_QPdfSearchModel_buddy(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex) *C.QModelIndex { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex) *qt6.QModelIndex, index *qt6.QModelIndex) *qt6.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Buddy, slotval1) + + return (*C.QModelIndex)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_Match(start *qt6.QModelIndex, role int, value *qt6.QVariant, hits int, flags qt6.MatchFlag) []qt6.QModelIndex { + + var _ma C.struct_miqt_array = C.QPdfSearchModel_virtualbase_match(unsafe.Pointer(this.h), (*C.QModelIndex)(start.UnsafePointer()), (C.int)(role), (*C.QVariant)(value.UnsafePointer()), (C.int)(hits), (C.int)(flags)) + _ret := make([]qt6.QModelIndex, int(_ma.len)) + _outCast := (*[0xffff]*C.QModelIndex)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt6.UnsafeNewQModelIndex(unsafe.Pointer(_outCast[i])) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret + +} +func (this *QPdfSearchModel) OnMatch(slot func(super func(start *qt6.QModelIndex, role int, value *qt6.QVariant, hits int, flags qt6.MatchFlag) []qt6.QModelIndex, start *qt6.QModelIndex, role int, value *qt6.QVariant, hits int, flags qt6.MatchFlag) []qt6.QModelIndex) { + ok := C.QPdfSearchModel_override_virtual_match(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_match +func miqt_exec_callback_QPdfSearchModel_match(self *C.QPdfSearchModel, cb C.intptr_t, start *C.QModelIndex, role C.int, value *C.QVariant, hits C.int, flags C.int) C.struct_miqt_array { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(start *qt6.QModelIndex, role int, value *qt6.QVariant, hits int, flags qt6.MatchFlag) []qt6.QModelIndex, start *qt6.QModelIndex, role int, value *qt6.QVariant, hits int, flags qt6.MatchFlag) []qt6.QModelIndex) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(start)) + + slotval2 := (int)(role) + + slotval3 := qt6.UnsafeNewQVariant(unsafe.Pointer(value)) + + slotval4 := (int)(hits) + + slotval5 := (qt6.MatchFlag)(flags) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Match, slotval1, slotval2, slotval3, slotval4, slotval5) + virtualReturn_CArray := (*[0xffff]*C.QModelIndex)(C.malloc(C.size_t(8 * len(virtualReturn)))) + defer C.free(unsafe.Pointer(virtualReturn_CArray)) + for i := range virtualReturn { + virtualReturn_CArray[i] = (*C.QModelIndex)(virtualReturn[i].UnsafePointer()) + } + virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)} + + return virtualReturn_ma + +} + +func (this *QPdfSearchModel) callVirtualBase_Span(index *qt6.QModelIndex) *qt6.QSize { + + _goptr := qt6.UnsafeNewQSize(unsafe.Pointer(C.QPdfSearchModel_virtualbase_span(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer())))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfSearchModel) OnSpan(slot func(super func(index *qt6.QModelIndex) *qt6.QSize, index *qt6.QModelIndex) *qt6.QSize) { + ok := C.QPdfSearchModel_override_virtual_span(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_span +func miqt_exec_callback_QPdfSearchModel_span(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex) *C.QSize { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex) *qt6.QSize, index *qt6.QModelIndex) *qt6.QSize) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Span, slotval1) + + return (*C.QSize)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfSearchModel) callVirtualBase_MultiData(index *qt6.QModelIndex, roleDataSpan qt6.QModelRoleDataSpan) { + + C.QPdfSearchModel_virtualbase_multiData(unsafe.Pointer(this.h), (*C.QModelIndex)(index.UnsafePointer()), (*C.QModelRoleDataSpan)(roleDataSpan.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnMultiData(slot func(super func(index *qt6.QModelIndex, roleDataSpan qt6.QModelRoleDataSpan), index *qt6.QModelIndex, roleDataSpan qt6.QModelRoleDataSpan)) { + ok := C.QPdfSearchModel_override_virtual_multiData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_multiData +func miqt_exec_callback_QPdfSearchModel_multiData(self *C.QPdfSearchModel, cb C.intptr_t, index *C.QModelIndex, roleDataSpan *C.QModelRoleDataSpan) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(index *qt6.QModelIndex, roleDataSpan qt6.QModelRoleDataSpan), index *qt6.QModelIndex, roleDataSpan qt6.QModelRoleDataSpan)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQModelIndex(unsafe.Pointer(index)) + + roleDataSpan_goptr := qt6.UnsafeNewQModelRoleDataSpan(unsafe.Pointer(roleDataSpan)) + roleDataSpan_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + slotval2 := *roleDataSpan_goptr + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_MultiData, slotval1, slotval2) + +} + +func (this *QPdfSearchModel) callVirtualBase_Submit() bool { + + return (bool)(C.QPdfSearchModel_virtualbase_submit(unsafe.Pointer(this.h))) + +} +func (this *QPdfSearchModel) OnSubmit(slot func(super func() bool) bool) { + ok := C.QPdfSearchModel_override_virtual_submit(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_submit +func miqt_exec_callback_QPdfSearchModel_submit(self *C.QPdfSearchModel, cb C.intptr_t) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Submit) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_Revert() { + + C.QPdfSearchModel_virtualbase_revert(unsafe.Pointer(this.h)) + +} +func (this *QPdfSearchModel) OnRevert(slot func(super func())) { + ok := C.QPdfSearchModel_override_virtual_revert(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_revert +func miqt_exec_callback_QPdfSearchModel_revert(self *C.QPdfSearchModel, cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func())) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Revert) + +} + +func (this *QPdfSearchModel) callVirtualBase_ResetInternalData() { + + C.QPdfSearchModel_virtualbase_resetInternalData(unsafe.Pointer(this.h)) + +} +func (this *QPdfSearchModel) OnResetInternalData(slot func(super func())) { + ok := C.QPdfSearchModel_override_virtual_resetInternalData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_resetInternalData +func miqt_exec_callback_QPdfSearchModel_resetInternalData(self *C.QPdfSearchModel, cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func())) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_ResetInternalData) + +} + +func (this *QPdfSearchModel) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QPdfSearchModel_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_event +func miqt_exec_callback_QPdfSearchModel_event(self *C.QPdfSearchModel, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QPdfSearchModel_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QPdfSearchModel) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QPdfSearchModel_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_eventFilter +func miqt_exec_callback_QPdfSearchModel_eventFilter(self *C.QPdfSearchModel, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QPdfSearchModel{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfSearchModel) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QPdfSearchModel_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QPdfSearchModel_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_childEvent +func miqt_exec_callback_QPdfSearchModel_childEvent(self *C.QPdfSearchModel, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QPdfSearchModel) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QPdfSearchModel_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QPdfSearchModel_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_customEvent +func miqt_exec_callback_QPdfSearchModel_customEvent(self *C.QPdfSearchModel, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent), event *qt6.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QPdfSearchModel) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QPdfSearchModel_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QPdfSearchModel_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_connectNotify +func miqt_exec_callback_QPdfSearchModel_connectNotify(self *C.QPdfSearchModel, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QPdfSearchModel) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QPdfSearchModel_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfSearchModel) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QPdfSearchModel_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfSearchModel_disconnectNotify +func miqt_exec_callback_QPdfSearchModel_disconnectNotify(self *C.QPdfSearchModel, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfSearchModel{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QPdfSearchModel) Delete() { + C.QPdfSearchModel_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfSearchModel) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfSearchModel) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/pdf/gen_qpdfsearchmodel.h b/qt6/pdf/gen_qpdfsearchmodel.h new file mode 100644 index 00000000..8a968471 --- /dev/null +++ b/qt6/pdf/gen_qpdfsearchmodel.h @@ -0,0 +1,190 @@ +#pragma once +#ifndef MIQT_QT6_PDF_GEN_QPDFSEARCHMODEL_H +#define MIQT_QT6_PDF_GEN_QPDFSEARCHMODEL_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractItemModel; +class QAbstractListModel; +class QChildEvent; +class QDataStream; +class QEvent; +class QMetaMethod; +class QMetaObject; +class QMimeData; +class QModelIndex; +class QModelRoleDataSpan; +class QObject; +class QPdfDocument; +class QPdfLink; +class QPdfSearchModel; +class QSize; +class QTimerEvent; +class QVariant; +#else +typedef struct QAbstractItemModel QAbstractItemModel; +typedef struct QAbstractListModel QAbstractListModel; +typedef struct QChildEvent QChildEvent; +typedef struct QDataStream QDataStream; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QMimeData QMimeData; +typedef struct QModelIndex QModelIndex; +typedef struct QModelRoleDataSpan QModelRoleDataSpan; +typedef struct QObject QObject; +typedef struct QPdfDocument QPdfDocument; +typedef struct QPdfLink QPdfLink; +typedef struct QPdfSearchModel QPdfSearchModel; +typedef struct QSize QSize; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +#endif + +QPdfSearchModel* QPdfSearchModel_new(); +QPdfSearchModel* QPdfSearchModel_new2(QObject* parent); +void QPdfSearchModel_virtbase(QPdfSearchModel* src, QAbstractListModel** outptr_QAbstractListModel); +QMetaObject* QPdfSearchModel_metaObject(const QPdfSearchModel* self); +void* QPdfSearchModel_metacast(QPdfSearchModel* self, const char* param1); +struct miqt_string QPdfSearchModel_tr(const char* s); +struct miqt_array /* of QPdfLink* */ QPdfSearchModel_resultsOnPage(const QPdfSearchModel* self, int page); +QPdfLink* QPdfSearchModel_resultAtIndex(const QPdfSearchModel* self, int index); +QPdfDocument* QPdfSearchModel_document(const QPdfSearchModel* self); +struct miqt_string QPdfSearchModel_searchString(const QPdfSearchModel* self); +struct miqt_map /* of int to struct miqt_string */ QPdfSearchModel_roleNames(const QPdfSearchModel* self); +int QPdfSearchModel_rowCount(const QPdfSearchModel* self, QModelIndex* parent); +QVariant* QPdfSearchModel_data(const QPdfSearchModel* self, QModelIndex* index, int role); +void QPdfSearchModel_setSearchString(QPdfSearchModel* self, struct miqt_string searchString); +void QPdfSearchModel_setDocument(QPdfSearchModel* self, QPdfDocument* document); +void QPdfSearchModel_documentChanged(QPdfSearchModel* self); +void QPdfSearchModel_connect_documentChanged(QPdfSearchModel* self, intptr_t slot); +void QPdfSearchModel_searchStringChanged(QPdfSearchModel* self); +void QPdfSearchModel_connect_searchStringChanged(QPdfSearchModel* self, intptr_t slot); +void QPdfSearchModel_timerEvent(QPdfSearchModel* self, QTimerEvent* event); +struct miqt_string QPdfSearchModel_tr2(const char* s, const char* c); +struct miqt_string QPdfSearchModel_tr3(const char* s, const char* c, int n); +bool QPdfSearchModel_override_virtual_roleNames(void* self, intptr_t slot); +struct miqt_map /* of int to struct miqt_string */ QPdfSearchModel_virtualbase_roleNames(const void* self); +bool QPdfSearchModel_override_virtual_rowCount(void* self, intptr_t slot); +int QPdfSearchModel_virtualbase_rowCount(const void* self, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_data(void* self, intptr_t slot); +QVariant* QPdfSearchModel_virtualbase_data(const void* self, QModelIndex* index, int role); +bool QPdfSearchModel_override_virtual_timerEvent(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QPdfSearchModel_override_virtual_index(void* self, intptr_t slot); +QModelIndex* QPdfSearchModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_sibling(void* self, intptr_t slot); +QModelIndex* QPdfSearchModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx); +bool QPdfSearchModel_override_virtual_dropMimeData(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_flags(void* self, intptr_t slot); +int QPdfSearchModel_virtualbase_flags(const void* self, QModelIndex* index); +bool QPdfSearchModel_override_virtual_setData(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role); +bool QPdfSearchModel_override_virtual_headerData(void* self, intptr_t slot); +QVariant* QPdfSearchModel_virtualbase_headerData(const void* self, int section, int orientation, int role); +bool QPdfSearchModel_override_virtual_setHeaderData(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role); +bool QPdfSearchModel_override_virtual_itemData(void* self, intptr_t slot); +struct miqt_map /* of int to QVariant* */ QPdfSearchModel_virtualbase_itemData(const void* self, QModelIndex* index); +bool QPdfSearchModel_override_virtual_setItemData(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */ roles); +bool QPdfSearchModel_override_virtual_clearItemData(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_clearItemData(void* self, QModelIndex* index); +bool QPdfSearchModel_override_virtual_mimeTypes(void* self, intptr_t slot); +struct miqt_array /* of struct miqt_string */ QPdfSearchModel_virtualbase_mimeTypes(const void* self); +bool QPdfSearchModel_override_virtual_mimeData(void* self, intptr_t slot); +QMimeData* QPdfSearchModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes); +bool QPdfSearchModel_override_virtual_canDropMimeData(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_supportedDropActions(void* self, intptr_t slot); +int QPdfSearchModel_virtualbase_supportedDropActions(const void* self); +bool QPdfSearchModel_override_virtual_supportedDragActions(void* self, intptr_t slot); +int QPdfSearchModel_virtualbase_supportedDragActions(const void* self); +bool QPdfSearchModel_override_virtual_insertRows(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_insertColumns(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_removeRows(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_removeColumns(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_moveRows(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild); +bool QPdfSearchModel_override_virtual_moveColumns(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild); +bool QPdfSearchModel_override_virtual_fetchMore(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_fetchMore(void* self, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_canFetchMore(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent); +bool QPdfSearchModel_override_virtual_sort(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_sort(void* self, int column, int order); +bool QPdfSearchModel_override_virtual_buddy(void* self, intptr_t slot); +QModelIndex* QPdfSearchModel_virtualbase_buddy(const void* self, QModelIndex* index); +bool QPdfSearchModel_override_virtual_match(void* self, intptr_t slot); +struct miqt_array /* of QModelIndex* */ QPdfSearchModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); +bool QPdfSearchModel_override_virtual_span(void* self, intptr_t slot); +QSize* QPdfSearchModel_virtualbase_span(const void* self, QModelIndex* index); +bool QPdfSearchModel_override_virtual_multiData(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_multiData(const void* self, QModelIndex* index, QModelRoleDataSpan* roleDataSpan); +bool QPdfSearchModel_override_virtual_submit(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_submit(void* self); +bool QPdfSearchModel_override_virtual_revert(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_revert(void* self); +bool QPdfSearchModel_override_virtual_resetInternalData(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_resetInternalData(void* self); +bool QPdfSearchModel_override_virtual_event(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_event(void* self, QEvent* event); +bool QPdfSearchModel_override_virtual_eventFilter(void* self, intptr_t slot); +bool QPdfSearchModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QPdfSearchModel_override_virtual_childEvent(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_childEvent(void* self, QChildEvent* event); +bool QPdfSearchModel_override_virtual_customEvent(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_customEvent(void* self, QEvent* event); +bool QPdfSearchModel_override_virtual_connectNotify(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QPdfSearchModel_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QPdfSearchModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); +void QPdfSearchModel_protectedbase_updatePage(bool* _dynamic_cast_ok, void* self, int page); +QModelIndex* QPdfSearchModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column); +void QPdfSearchModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */ indexes, QDataStream* stream); +bool QPdfSearchModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream); +void QPdfSearchModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfSearchModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self); +void QPdfSearchModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfSearchModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self); +bool QPdfSearchModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow); +void QPdfSearchModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self); +void QPdfSearchModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfSearchModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self); +void QPdfSearchModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last); +void QPdfSearchModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self); +bool QPdfSearchModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn); +void QPdfSearchModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self); +void QPdfSearchModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self); +void QPdfSearchModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self); +void QPdfSearchModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to); +void QPdfSearchModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */ from, struct miqt_array /* of QModelIndex* */ to); +struct miqt_array /* of QModelIndex* */ QPdfSearchModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self); +QObject* QPdfSearchModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QPdfSearchModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QPdfSearchModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QPdfSearchModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +void QPdfSearchModel_delete(QPdfSearchModel* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/pdf/gen_qpdfselection.cpp b/qt6/pdf/gen_qpdfselection.cpp new file mode 100644 index 00000000..6760580f --- /dev/null +++ b/qt6/pdf/gen_qpdfselection.cpp @@ -0,0 +1,67 @@ +#include +#include +#include +#include +#include +#include +#include "gen_qpdfselection.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +QPdfSelection* QPdfSelection_new(QPdfSelection* other) { + return new QPdfSelection(*other); +} + +void QPdfSelection_operatorAssign(QPdfSelection* self, QPdfSelection* other) { + self->operator=(*other); +} + +void QPdfSelection_swap(QPdfSelection* self, QPdfSelection* other) { + self->swap(*other); +} + +bool QPdfSelection_isValid(const QPdfSelection* self) { + return self->isValid(); +} + +struct miqt_string QPdfSelection_text(const QPdfSelection* self) { + QString _ret = self->text(); + // 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; +} + +QRectF* QPdfSelection_boundingRectangle(const QPdfSelection* self) { + return new QRectF(self->boundingRectangle()); +} + +int QPdfSelection_startIndex(const QPdfSelection* self) { + return self->startIndex(); +} + +int QPdfSelection_endIndex(const QPdfSelection* self) { + return self->endIndex(); +} + +void QPdfSelection_copyToClipboard(const QPdfSelection* self) { + self->copyToClipboard(); +} + +void QPdfSelection_copyToClipboardWithMode(const QPdfSelection* self, int mode) { + self->copyToClipboard(static_cast(mode)); +} + +void QPdfSelection_delete(QPdfSelection* self) { + delete self; +} + diff --git a/qt6/pdf/gen_qpdfselection.go b/qt6/pdf/gen_qpdfselection.go new file mode 100644 index 00000000..c27684c2 --- /dev/null +++ b/qt6/pdf/gen_qpdfselection.go @@ -0,0 +1,108 @@ +package pdf + +/* + +#include "gen_qpdfselection.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "unsafe" +) + +type QPdfSelection struct { + h *C.QPdfSelection +} + +func (this *QPdfSelection) cPointer() *C.QPdfSelection { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfSelection) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfSelection constructs the type using only CGO pointers. +func newQPdfSelection(h *C.QPdfSelection) *QPdfSelection { + if h == nil { + return nil + } + + return &QPdfSelection{h: h} +} + +// UnsafeNewQPdfSelection constructs the type using only unsafe pointers. +func UnsafeNewQPdfSelection(h unsafe.Pointer) *QPdfSelection { + return newQPdfSelection((*C.QPdfSelection)(h)) +} + +// NewQPdfSelection constructs a new QPdfSelection object. +func NewQPdfSelection(other *QPdfSelection) *QPdfSelection { + + return newQPdfSelection(C.QPdfSelection_new(other.cPointer())) +} + +func (this *QPdfSelection) OperatorAssign(other *QPdfSelection) { + C.QPdfSelection_operatorAssign(this.h, other.cPointer()) +} + +func (this *QPdfSelection) Swap(other *QPdfSelection) { + C.QPdfSelection_swap(this.h, other.cPointer()) +} + +func (this *QPdfSelection) IsValid() bool { + return (bool)(C.QPdfSelection_isValid(this.h)) +} + +func (this *QPdfSelection) Text() string { + var _ms C.struct_miqt_string = C.QPdfSelection_text(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfSelection) BoundingRectangle() *qt6.QRectF { + _goptr := qt6.UnsafeNewQRectF(unsafe.Pointer(C.QPdfSelection_boundingRectangle(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfSelection) StartIndex() int { + return (int)(C.QPdfSelection_startIndex(this.h)) +} + +func (this *QPdfSelection) EndIndex() int { + return (int)(C.QPdfSelection_endIndex(this.h)) +} + +func (this *QPdfSelection) CopyToClipboard() { + C.QPdfSelection_copyToClipboard(this.h) +} + +func (this *QPdfSelection) CopyToClipboardWithMode(mode qt6.QClipboard__Mode) { + C.QPdfSelection_copyToClipboardWithMode(this.h, (C.int)(mode)) +} + +// Delete this object from C++ memory. +func (this *QPdfSelection) Delete() { + C.QPdfSelection_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfSelection) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfSelection) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/pdf/gen_qpdfselection.h b/qt6/pdf/gen_qpdfselection.h new file mode 100644 index 00000000..3f6b31d0 --- /dev/null +++ b/qt6/pdf/gen_qpdfselection.h @@ -0,0 +1,41 @@ +#pragma once +#ifndef MIQT_QT6_PDF_GEN_QPDFSELECTION_H +#define MIQT_QT6_PDF_GEN_QPDFSELECTION_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QPdfSelection; +class QRectF; +#else +typedef struct QPdfSelection QPdfSelection; +typedef struct QRectF QRectF; +#endif + +QPdfSelection* QPdfSelection_new(QPdfSelection* other); +void QPdfSelection_operatorAssign(QPdfSelection* self, QPdfSelection* other); +void QPdfSelection_swap(QPdfSelection* self, QPdfSelection* other); +bool QPdfSelection_isValid(const QPdfSelection* self); +struct miqt_string QPdfSelection_text(const QPdfSelection* self); +QRectF* QPdfSelection_boundingRectangle(const QPdfSelection* self); +int QPdfSelection_startIndex(const QPdfSelection* self); +int QPdfSelection_endIndex(const QPdfSelection* self); +void QPdfSelection_copyToClipboard(const QPdfSelection* self); +void QPdfSelection_copyToClipboardWithMode(const QPdfSelection* self, int mode); +void QPdfSelection_delete(QPdfSelection* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/pdf/gen_qpdfview.cpp b/qt6/pdf/gen_qpdfview.cpp new file mode 100644 index 00000000..76bf1293 --- /dev/null +++ b/qt6/pdf/gen_qpdfview.cpp @@ -0,0 +1,2286 @@ +#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 +#include +#include +#include +#include +#include +#include +#include +#include "gen_qpdfview.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QPdfView_documentChanged(intptr_t, QPdfDocument*); +void miqt_exec_callback_QPdfView_pageModeChanged(intptr_t, int); +void miqt_exec_callback_QPdfView_zoomModeChanged(intptr_t, int); +void miqt_exec_callback_QPdfView_zoomFactorChanged(intptr_t, double); +void miqt_exec_callback_QPdfView_pageSpacingChanged(intptr_t, int); +void miqt_exec_callback_QPdfView_documentMarginsChanged(intptr_t, QMargins*); +void miqt_exec_callback_QPdfView_paintEvent(QPdfView*, intptr_t, QPaintEvent*); +void miqt_exec_callback_QPdfView_resizeEvent(QPdfView*, intptr_t, QResizeEvent*); +void miqt_exec_callback_QPdfView_scrollContentsBy(QPdfView*, intptr_t, int, int); +QSize* miqt_exec_callback_QPdfView_minimumSizeHint(const QPdfView*, intptr_t); +QSize* miqt_exec_callback_QPdfView_sizeHint(const QPdfView*, intptr_t); +void miqt_exec_callback_QPdfView_setupViewport(QPdfView*, intptr_t, QWidget*); +bool miqt_exec_callback_QPdfView_eventFilter(QPdfView*, intptr_t, QObject*, QEvent*); +bool miqt_exec_callback_QPdfView_event(QPdfView*, intptr_t, QEvent*); +bool miqt_exec_callback_QPdfView_viewportEvent(QPdfView*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfView_mousePressEvent(QPdfView*, intptr_t, QMouseEvent*); +void miqt_exec_callback_QPdfView_mouseReleaseEvent(QPdfView*, intptr_t, QMouseEvent*); +void miqt_exec_callback_QPdfView_mouseDoubleClickEvent(QPdfView*, intptr_t, QMouseEvent*); +void miqt_exec_callback_QPdfView_mouseMoveEvent(QPdfView*, intptr_t, QMouseEvent*); +void miqt_exec_callback_QPdfView_wheelEvent(QPdfView*, intptr_t, QWheelEvent*); +void miqt_exec_callback_QPdfView_contextMenuEvent(QPdfView*, intptr_t, QContextMenuEvent*); +void miqt_exec_callback_QPdfView_dragEnterEvent(QPdfView*, intptr_t, QDragEnterEvent*); +void miqt_exec_callback_QPdfView_dragMoveEvent(QPdfView*, intptr_t, QDragMoveEvent*); +void miqt_exec_callback_QPdfView_dragLeaveEvent(QPdfView*, intptr_t, QDragLeaveEvent*); +void miqt_exec_callback_QPdfView_dropEvent(QPdfView*, intptr_t, QDropEvent*); +void miqt_exec_callback_QPdfView_keyPressEvent(QPdfView*, intptr_t, QKeyEvent*); +QSize* miqt_exec_callback_QPdfView_viewportSizeHint(const QPdfView*, intptr_t); +void miqt_exec_callback_QPdfView_changeEvent(QPdfView*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfView_initStyleOption(const QPdfView*, intptr_t, QStyleOptionFrame*); +int miqt_exec_callback_QPdfView_devType(const QPdfView*, intptr_t); +void miqt_exec_callback_QPdfView_setVisible(QPdfView*, intptr_t, bool); +int miqt_exec_callback_QPdfView_heightForWidth(const QPdfView*, intptr_t, int); +bool miqt_exec_callback_QPdfView_hasHeightForWidth(const QPdfView*, intptr_t); +QPaintEngine* miqt_exec_callback_QPdfView_paintEngine(const QPdfView*, intptr_t); +void miqt_exec_callback_QPdfView_keyReleaseEvent(QPdfView*, intptr_t, QKeyEvent*); +void miqt_exec_callback_QPdfView_focusInEvent(QPdfView*, intptr_t, QFocusEvent*); +void miqt_exec_callback_QPdfView_focusOutEvent(QPdfView*, intptr_t, QFocusEvent*); +void miqt_exec_callback_QPdfView_enterEvent(QPdfView*, intptr_t, QEnterEvent*); +void miqt_exec_callback_QPdfView_leaveEvent(QPdfView*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfView_moveEvent(QPdfView*, intptr_t, QMoveEvent*); +void miqt_exec_callback_QPdfView_closeEvent(QPdfView*, intptr_t, QCloseEvent*); +void miqt_exec_callback_QPdfView_tabletEvent(QPdfView*, intptr_t, QTabletEvent*); +void miqt_exec_callback_QPdfView_actionEvent(QPdfView*, intptr_t, QActionEvent*); +void miqt_exec_callback_QPdfView_showEvent(QPdfView*, intptr_t, QShowEvent*); +void miqt_exec_callback_QPdfView_hideEvent(QPdfView*, intptr_t, QHideEvent*); +bool miqt_exec_callback_QPdfView_nativeEvent(QPdfView*, intptr_t, struct miqt_string, void*, intptr_t*); +int miqt_exec_callback_QPdfView_metric(const QPdfView*, intptr_t, int); +void miqt_exec_callback_QPdfView_initPainter(const QPdfView*, intptr_t, QPainter*); +QPaintDevice* miqt_exec_callback_QPdfView_redirected(const QPdfView*, intptr_t, QPoint*); +QPainter* miqt_exec_callback_QPdfView_sharedPainter(const QPdfView*, intptr_t); +void miqt_exec_callback_QPdfView_inputMethodEvent(QPdfView*, intptr_t, QInputMethodEvent*); +QVariant* miqt_exec_callback_QPdfView_inputMethodQuery(const QPdfView*, intptr_t, int); +bool miqt_exec_callback_QPdfView_focusNextPrevChild(QPdfView*, intptr_t, bool); +void miqt_exec_callback_QPdfView_timerEvent(QPdfView*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QPdfView_childEvent(QPdfView*, intptr_t, QChildEvent*); +void miqt_exec_callback_QPdfView_customEvent(QPdfView*, intptr_t, QEvent*); +void miqt_exec_callback_QPdfView_connectNotify(QPdfView*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QPdfView_disconnectNotify(QPdfView*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQPdfView final : public QPdfView { +public: + + MiqtVirtualQPdfView(QWidget* parent): QPdfView(parent) {}; + MiqtVirtualQPdfView(): QPdfView() {}; + + virtual ~MiqtVirtualQPdfView() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__paintEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void paintEvent(QPaintEvent* event) override { + if (handle__paintEvent == 0) { + QPdfView::paintEvent(event); + return; + } + + QPaintEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_paintEvent(this, handle__paintEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_paintEvent(void* self, QPaintEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__resizeEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void resizeEvent(QResizeEvent* event) override { + if (handle__resizeEvent == 0) { + QPdfView::resizeEvent(event); + return; + } + + QResizeEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_resizeEvent(this, handle__resizeEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_resizeEvent(void* self, QResizeEvent* event); + + // 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) { + QPdfView::scrollContentsBy(dx, dy); + return; + } + + int sigval1 = dx; + int sigval2 = dy; + + miqt_exec_callback_QPdfView_scrollContentsBy(this, handle__scrollContentsBy, sigval1, sigval2); + + + } + + friend void QPdfView_virtualbase_scrollContentsBy(void* self, int dx, int dy); + + // cgo.Handle value for overwritten implementation + intptr_t handle__minimumSizeHint = 0; + + // Subclass to allow providing a Go implementation + virtual QSize minimumSizeHint() const override { + if (handle__minimumSizeHint == 0) { + return QPdfView::minimumSizeHint(); + } + + + QSize* callback_return_value = miqt_exec_callback_QPdfView_minimumSizeHint(this, handle__minimumSizeHint); + + return *callback_return_value; + } + + friend QSize* QPdfView_virtualbase_minimumSizeHint(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__sizeHint = 0; + + // Subclass to allow providing a Go implementation + virtual QSize sizeHint() const override { + if (handle__sizeHint == 0) { + return QPdfView::sizeHint(); + } + + + QSize* callback_return_value = miqt_exec_callback_QPdfView_sizeHint(this, handle__sizeHint); + + return *callback_return_value; + } + + friend QSize* QPdfView_virtualbase_sizeHint(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setupViewport = 0; + + // Subclass to allow providing a Go implementation + virtual void setupViewport(QWidget* viewport) override { + if (handle__setupViewport == 0) { + QPdfView::setupViewport(viewport); + return; + } + + QWidget* sigval1 = viewport; + + miqt_exec_callback_QPdfView_setupViewport(this, handle__setupViewport, sigval1); + + + } + + friend void QPdfView_virtualbase_setupViewport(void* self, QWidget* viewport); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* param1, QEvent* param2) override { + if (handle__eventFilter == 0) { + return QPdfView::eventFilter(param1, param2); + } + + QObject* sigval1 = param1; + QEvent* sigval2 = param2; + + bool callback_return_value = miqt_exec_callback_QPdfView_eventFilter(this, handle__eventFilter, sigval1, sigval2); + + return callback_return_value; + } + + friend bool QPdfView_virtualbase_eventFilter(void* self, QObject* param1, QEvent* param2); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* param1) override { + if (handle__event == 0) { + return QPdfView::event(param1); + } + + QEvent* sigval1 = param1; + + bool callback_return_value = miqt_exec_callback_QPdfView_event(this, handle__event, sigval1); + + return callback_return_value; + } + + friend bool QPdfView_virtualbase_event(void* self, QEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__viewportEvent = 0; + + // Subclass to allow providing a Go implementation + virtual bool viewportEvent(QEvent* param1) override { + if (handle__viewportEvent == 0) { + return QPdfView::viewportEvent(param1); + } + + QEvent* sigval1 = param1; + + bool callback_return_value = miqt_exec_callback_QPdfView_viewportEvent(this, handle__viewportEvent, sigval1); + + return callback_return_value; + } + + friend bool QPdfView_virtualbase_viewportEvent(void* self, QEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mousePressEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void mousePressEvent(QMouseEvent* param1) override { + if (handle__mousePressEvent == 0) { + QPdfView::mousePressEvent(param1); + return; + } + + QMouseEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_mousePressEvent(this, handle__mousePressEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_mousePressEvent(void* self, QMouseEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mouseReleaseEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void mouseReleaseEvent(QMouseEvent* param1) override { + if (handle__mouseReleaseEvent == 0) { + QPdfView::mouseReleaseEvent(param1); + return; + } + + QMouseEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_mouseReleaseEvent(this, handle__mouseReleaseEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mouseDoubleClickEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void mouseDoubleClickEvent(QMouseEvent* param1) override { + if (handle__mouseDoubleClickEvent == 0) { + QPdfView::mouseDoubleClickEvent(param1); + return; + } + + QMouseEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_mouseDoubleClickEvent(this, handle__mouseDoubleClickEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__mouseMoveEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void mouseMoveEvent(QMouseEvent* param1) override { + if (handle__mouseMoveEvent == 0) { + QPdfView::mouseMoveEvent(param1); + return; + } + + QMouseEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_mouseMoveEvent(this, handle__mouseMoveEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_mouseMoveEvent(void* self, QMouseEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__wheelEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void wheelEvent(QWheelEvent* param1) override { + if (handle__wheelEvent == 0) { + QPdfView::wheelEvent(param1); + return; + } + + QWheelEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_wheelEvent(this, handle__wheelEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_wheelEvent(void* self, QWheelEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__contextMenuEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void contextMenuEvent(QContextMenuEvent* param1) override { + if (handle__contextMenuEvent == 0) { + QPdfView::contextMenuEvent(param1); + return; + } + + QContextMenuEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_contextMenuEvent(this, handle__contextMenuEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__dragEnterEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void dragEnterEvent(QDragEnterEvent* param1) override { + if (handle__dragEnterEvent == 0) { + QPdfView::dragEnterEvent(param1); + return; + } + + QDragEnterEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_dragEnterEvent(this, handle__dragEnterEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__dragMoveEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void dragMoveEvent(QDragMoveEvent* param1) override { + if (handle__dragMoveEvent == 0) { + QPdfView::dragMoveEvent(param1); + return; + } + + QDragMoveEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_dragMoveEvent(this, handle__dragMoveEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__dragLeaveEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void dragLeaveEvent(QDragLeaveEvent* param1) override { + if (handle__dragLeaveEvent == 0) { + QPdfView::dragLeaveEvent(param1); + return; + } + + QDragLeaveEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_dragLeaveEvent(this, handle__dragLeaveEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__dropEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void dropEvent(QDropEvent* param1) override { + if (handle__dropEvent == 0) { + QPdfView::dropEvent(param1); + return; + } + + QDropEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_dropEvent(this, handle__dropEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_dropEvent(void* self, QDropEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__keyPressEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void keyPressEvent(QKeyEvent* param1) override { + if (handle__keyPressEvent == 0) { + QPdfView::keyPressEvent(param1); + return; + } + + QKeyEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_keyPressEvent(this, handle__keyPressEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_keyPressEvent(void* self, QKeyEvent* param1); + + // 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 QPdfView::viewportSizeHint(); + } + + + QSize* callback_return_value = miqt_exec_callback_QPdfView_viewportSizeHint(this, handle__viewportSizeHint); + + return *callback_return_value; + } + + friend QSize* QPdfView_virtualbase_viewportSizeHint(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__changeEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void changeEvent(QEvent* param1) override { + if (handle__changeEvent == 0) { + QPdfView::changeEvent(param1); + return; + } + + QEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_changeEvent(this, handle__changeEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_changeEvent(void* self, QEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__initStyleOption = 0; + + // Subclass to allow providing a Go implementation + virtual void initStyleOption(QStyleOptionFrame* option) const override { + if (handle__initStyleOption == 0) { + QPdfView::initStyleOption(option); + return; + } + + QStyleOptionFrame* sigval1 = option; + + miqt_exec_callback_QPdfView_initStyleOption(this, handle__initStyleOption, sigval1); + + + } + + friend void QPdfView_virtualbase_initStyleOption(const void* self, QStyleOptionFrame* option); + + // cgo.Handle value for overwritten implementation + intptr_t handle__devType = 0; + + // Subclass to allow providing a Go implementation + virtual int devType() const override { + if (handle__devType == 0) { + return QPdfView::devType(); + } + + + int callback_return_value = miqt_exec_callback_QPdfView_devType(this, handle__devType); + + return static_cast(callback_return_value); + } + + friend int QPdfView_virtualbase_devType(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setVisible = 0; + + // Subclass to allow providing a Go implementation + virtual void setVisible(bool visible) override { + if (handle__setVisible == 0) { + QPdfView::setVisible(visible); + return; + } + + bool sigval1 = visible; + + miqt_exec_callback_QPdfView_setVisible(this, handle__setVisible, sigval1); + + + } + + friend void QPdfView_virtualbase_setVisible(void* self, bool visible); + + // cgo.Handle value for overwritten implementation + intptr_t handle__heightForWidth = 0; + + // Subclass to allow providing a Go implementation + virtual int heightForWidth(int param1) const override { + if (handle__heightForWidth == 0) { + return QPdfView::heightForWidth(param1); + } + + int sigval1 = param1; + + int callback_return_value = miqt_exec_callback_QPdfView_heightForWidth(this, handle__heightForWidth, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfView_virtualbase_heightForWidth(const void* self, int param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__hasHeightForWidth = 0; + + // Subclass to allow providing a Go implementation + virtual bool hasHeightForWidth() const override { + if (handle__hasHeightForWidth == 0) { + return QPdfView::hasHeightForWidth(); + } + + + bool callback_return_value = miqt_exec_callback_QPdfView_hasHeightForWidth(this, handle__hasHeightForWidth); + + return callback_return_value; + } + + friend bool QPdfView_virtualbase_hasHeightForWidth(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__paintEngine = 0; + + // Subclass to allow providing a Go implementation + virtual QPaintEngine* paintEngine() const override { + if (handle__paintEngine == 0) { + return QPdfView::paintEngine(); + } + + + QPaintEngine* callback_return_value = miqt_exec_callback_QPdfView_paintEngine(this, handle__paintEngine); + + return callback_return_value; + } + + friend QPaintEngine* QPdfView_virtualbase_paintEngine(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__keyReleaseEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void keyReleaseEvent(QKeyEvent* event) override { + if (handle__keyReleaseEvent == 0) { + QPdfView::keyReleaseEvent(event); + return; + } + + QKeyEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_keyReleaseEvent(this, handle__keyReleaseEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_keyReleaseEvent(void* self, QKeyEvent* 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) { + QPdfView::focusInEvent(event); + return; + } + + QFocusEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_focusInEvent(this, handle__focusInEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_focusInEvent(void* self, QFocusEvent* 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) { + QPdfView::focusOutEvent(event); + return; + } + + QFocusEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_focusOutEvent(this, handle__focusOutEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_focusOutEvent(void* self, QFocusEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__enterEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void enterEvent(QEnterEvent* event) override { + if (handle__enterEvent == 0) { + QPdfView::enterEvent(event); + return; + } + + QEnterEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_enterEvent(this, handle__enterEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_enterEvent(void* self, QEnterEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__leaveEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void leaveEvent(QEvent* event) override { + if (handle__leaveEvent == 0) { + QPdfView::leaveEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_leaveEvent(this, handle__leaveEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_leaveEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__moveEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void moveEvent(QMoveEvent* event) override { + if (handle__moveEvent == 0) { + QPdfView::moveEvent(event); + return; + } + + QMoveEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_moveEvent(this, handle__moveEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_moveEvent(void* self, QMoveEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__closeEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void closeEvent(QCloseEvent* event) override { + if (handle__closeEvent == 0) { + QPdfView::closeEvent(event); + return; + } + + QCloseEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_closeEvent(this, handle__closeEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_closeEvent(void* self, QCloseEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__tabletEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void tabletEvent(QTabletEvent* event) override { + if (handle__tabletEvent == 0) { + QPdfView::tabletEvent(event); + return; + } + + QTabletEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_tabletEvent(this, handle__tabletEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_tabletEvent(void* self, QTabletEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__actionEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void actionEvent(QActionEvent* event) override { + if (handle__actionEvent == 0) { + QPdfView::actionEvent(event); + return; + } + + QActionEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_actionEvent(this, handle__actionEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_actionEvent(void* self, QActionEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__showEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void showEvent(QShowEvent* event) override { + if (handle__showEvent == 0) { + QPdfView::showEvent(event); + return; + } + + QShowEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_showEvent(this, handle__showEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_showEvent(void* self, QShowEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__hideEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void hideEvent(QHideEvent* event) override { + if (handle__hideEvent == 0) { + QPdfView::hideEvent(event); + return; + } + + QHideEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_hideEvent(this, handle__hideEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_hideEvent(void* self, QHideEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__nativeEvent = 0; + + // Subclass to allow providing a Go implementation + virtual bool nativeEvent(const QByteArray& eventType, void* message, qintptr* result) override { + if (handle__nativeEvent == 0) { + return QPdfView::nativeEvent(eventType, message, result); + } + + const QByteArray eventType_qb = eventType; + struct miqt_string eventType_ms; + eventType_ms.len = eventType_qb.length(); + eventType_ms.data = static_cast(malloc(eventType_ms.len)); + memcpy(eventType_ms.data, eventType_qb.data(), eventType_ms.len); + struct miqt_string sigval1 = eventType_ms; + void* sigval2 = message; + qintptr* result_ret = result; + intptr_t* sigval3 = (intptr_t*)(result_ret); + + bool callback_return_value = miqt_exec_callback_QPdfView_nativeEvent(this, handle__nativeEvent, sigval1, sigval2, sigval3); + + return callback_return_value; + } + + friend bool QPdfView_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, intptr_t* result); + + // cgo.Handle value for overwritten implementation + intptr_t handle__metric = 0; + + // Subclass to allow providing a Go implementation + virtual int metric(QPaintDevice::PaintDeviceMetric param1) const override { + if (handle__metric == 0) { + return QPdfView::metric(param1); + } + + QPaintDevice::PaintDeviceMetric param1_ret = param1; + int sigval1 = static_cast(param1_ret); + + int callback_return_value = miqt_exec_callback_QPdfView_metric(this, handle__metric, sigval1); + + return static_cast(callback_return_value); + } + + friend int QPdfView_virtualbase_metric(const void* self, int param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__initPainter = 0; + + // Subclass to allow providing a Go implementation + virtual void initPainter(QPainter* painter) const override { + if (handle__initPainter == 0) { + QPdfView::initPainter(painter); + return; + } + + QPainter* sigval1 = painter; + + miqt_exec_callback_QPdfView_initPainter(this, handle__initPainter, sigval1); + + + } + + friend void QPdfView_virtualbase_initPainter(const void* self, QPainter* painter); + + // cgo.Handle value for overwritten implementation + intptr_t handle__redirected = 0; + + // Subclass to allow providing a Go implementation + virtual QPaintDevice* redirected(QPoint* offset) const override { + if (handle__redirected == 0) { + return QPdfView::redirected(offset); + } + + QPoint* sigval1 = offset; + + QPaintDevice* callback_return_value = miqt_exec_callback_QPdfView_redirected(this, handle__redirected, sigval1); + + return callback_return_value; + } + + friend QPaintDevice* QPdfView_virtualbase_redirected(const void* self, QPoint* offset); + + // cgo.Handle value for overwritten implementation + intptr_t handle__sharedPainter = 0; + + // Subclass to allow providing a Go implementation + virtual QPainter* sharedPainter() const override { + if (handle__sharedPainter == 0) { + return QPdfView::sharedPainter(); + } + + + QPainter* callback_return_value = miqt_exec_callback_QPdfView_sharedPainter(this, handle__sharedPainter); + + return callback_return_value; + } + + friend QPainter* QPdfView_virtualbase_sharedPainter(const void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__inputMethodEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void inputMethodEvent(QInputMethodEvent* param1) override { + if (handle__inputMethodEvent == 0) { + QPdfView::inputMethodEvent(param1); + return; + } + + QInputMethodEvent* sigval1 = param1; + + miqt_exec_callback_QPdfView_inputMethodEvent(this, handle__inputMethodEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* param1); + + // cgo.Handle value for overwritten implementation + intptr_t handle__inputMethodQuery = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant inputMethodQuery(Qt::InputMethodQuery param1) const override { + if (handle__inputMethodQuery == 0) { + return QPdfView::inputMethodQuery(param1); + } + + Qt::InputMethodQuery param1_ret = param1; + int sigval1 = static_cast(param1_ret); + + QVariant* callback_return_value = miqt_exec_callback_QPdfView_inputMethodQuery(this, handle__inputMethodQuery, sigval1); + + return *callback_return_value; + } + + friend QVariant* QPdfView_virtualbase_inputMethodQuery(const void* self, int param1); + + // 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 QPdfView::focusNextPrevChild(next); + } + + bool sigval1 = next; + + bool callback_return_value = miqt_exec_callback_QPdfView_focusNextPrevChild(this, handle__focusNextPrevChild, sigval1); + + return callback_return_value; + } + + friend bool QPdfView_virtualbase_focusNextPrevChild(void* self, bool next); + + // cgo.Handle value for overwritten implementation + intptr_t handle__timerEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void timerEvent(QTimerEvent* event) override { + if (handle__timerEvent == 0) { + QPdfView::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_timerEvent(this, handle__timerEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_timerEvent(void* self, QTimerEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__childEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void childEvent(QChildEvent* event) override { + if (handle__childEvent == 0) { + QPdfView::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_childEvent(this, handle__childEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_childEvent(void* self, QChildEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__customEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void customEvent(QEvent* event) override { + if (handle__customEvent == 0) { + QPdfView::customEvent(event); + return; + } + + QEvent* sigval1 = event; + + miqt_exec_callback_QPdfView_customEvent(this, handle__customEvent, sigval1); + + + } + + friend void QPdfView_virtualbase_customEvent(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__connectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void connectNotify(const QMetaMethod& signal) override { + if (handle__connectNotify == 0) { + QPdfView::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfView_connectNotify(this, handle__connectNotify, sigval1); + + + } + + friend void QPdfView_virtualbase_connectNotify(void* self, QMetaMethod* signal); + + // cgo.Handle value for overwritten implementation + intptr_t handle__disconnectNotify = 0; + + // Subclass to allow providing a Go implementation + virtual void disconnectNotify(const QMetaMethod& signal) override { + if (handle__disconnectNotify == 0) { + QPdfView::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + + miqt_exec_callback_QPdfView_disconnectNotify(this, handle__disconnectNotify, sigval1); + + + } + + friend void QPdfView_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend void QPdfView_protectedbase_setViewportMargins(bool* _dynamic_cast_ok, void* self, int left, int top, int right, int bottom); + friend QMargins* QPdfView_protectedbase_viewportMargins(bool* _dynamic_cast_ok, const void* self); + friend void QPdfView_protectedbase_drawFrame(bool* _dynamic_cast_ok, void* self, QPainter* param1); + friend void QPdfView_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self); + friend void QPdfView_protectedbase_create(bool* _dynamic_cast_ok, void* self); + friend void QPdfView_protectedbase_destroy(bool* _dynamic_cast_ok, void* self); + friend bool QPdfView_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self); + friend bool QPdfView_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self); + friend QObject* QPdfView_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QPdfView_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QPdfView_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QPdfView_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QPdfView* QPdfView_new(QWidget* parent) { + return new MiqtVirtualQPdfView(parent); +} + +QPdfView* QPdfView_new2() { + return new MiqtVirtualQPdfView(); +} + +void QPdfView_virtbase(QPdfView* src, QAbstractScrollArea** outptr_QAbstractScrollArea) { + *outptr_QAbstractScrollArea = static_cast(src); +} + +QMetaObject* QPdfView_metaObject(const QPdfView* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QPdfView_metacast(QPdfView* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QPdfView_tr(const char* s) { + QString _ret = QPdfView::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; +} + +void QPdfView_setDocument(QPdfView* self, QPdfDocument* document) { + self->setDocument(document); +} + +QPdfDocument* QPdfView_document(const QPdfView* self) { + return self->document(); +} + +QPdfPageNavigator* QPdfView_pageNavigator(const QPdfView* self) { + return self->pageNavigator(); +} + +int QPdfView_pageMode(const QPdfView* self) { + QPdfView::PageMode _ret = self->pageMode(); + return static_cast(_ret); +} + +int QPdfView_zoomMode(const QPdfView* self) { + QPdfView::ZoomMode _ret = self->zoomMode(); + return static_cast(_ret); +} + +double QPdfView_zoomFactor(const QPdfView* self) { + qreal _ret = self->zoomFactor(); + return static_cast(_ret); +} + +int QPdfView_pageSpacing(const QPdfView* self) { + return self->pageSpacing(); +} + +void QPdfView_setPageSpacing(QPdfView* self, int spacing) { + self->setPageSpacing(static_cast(spacing)); +} + +QMargins* QPdfView_documentMargins(const QPdfView* self) { + return new QMargins(self->documentMargins()); +} + +void QPdfView_setDocumentMargins(QPdfView* self, QMargins* margins) { + self->setDocumentMargins(*margins); +} + +void QPdfView_setPageMode(QPdfView* self, int mode) { + self->setPageMode(static_cast(mode)); +} + +void QPdfView_setZoomMode(QPdfView* self, int mode) { + self->setZoomMode(static_cast(mode)); +} + +void QPdfView_setZoomFactor(QPdfView* self, double factor) { + self->setZoomFactor(static_cast(factor)); +} + +void QPdfView_documentChanged(QPdfView* self, QPdfDocument* document) { + self->documentChanged(document); +} + +void QPdfView_connect_documentChanged(QPdfView* self, intptr_t slot) { + MiqtVirtualQPdfView::connect(self, static_cast(&QPdfView::documentChanged), self, [=](QPdfDocument* document) { + QPdfDocument* sigval1 = document; + miqt_exec_callback_QPdfView_documentChanged(slot, sigval1); + }); +} + +void QPdfView_pageModeChanged(QPdfView* self, int pageMode) { + self->pageModeChanged(static_cast(pageMode)); +} + +void QPdfView_connect_pageModeChanged(QPdfView* self, intptr_t slot) { + MiqtVirtualQPdfView::connect(self, static_cast(&QPdfView::pageModeChanged), self, [=](QPdfView::PageMode pageMode) { + QPdfView::PageMode pageMode_ret = pageMode; + int sigval1 = static_cast(pageMode_ret); + miqt_exec_callback_QPdfView_pageModeChanged(slot, sigval1); + }); +} + +void QPdfView_zoomModeChanged(QPdfView* self, int zoomMode) { + self->zoomModeChanged(static_cast(zoomMode)); +} + +void QPdfView_connect_zoomModeChanged(QPdfView* self, intptr_t slot) { + MiqtVirtualQPdfView::connect(self, static_cast(&QPdfView::zoomModeChanged), self, [=](QPdfView::ZoomMode zoomMode) { + QPdfView::ZoomMode zoomMode_ret = zoomMode; + int sigval1 = static_cast(zoomMode_ret); + miqt_exec_callback_QPdfView_zoomModeChanged(slot, sigval1); + }); +} + +void QPdfView_zoomFactorChanged(QPdfView* self, double zoomFactor) { + self->zoomFactorChanged(static_cast(zoomFactor)); +} + +void QPdfView_connect_zoomFactorChanged(QPdfView* self, intptr_t slot) { + MiqtVirtualQPdfView::connect(self, static_cast(&QPdfView::zoomFactorChanged), self, [=](qreal zoomFactor) { + qreal zoomFactor_ret = zoomFactor; + double sigval1 = static_cast(zoomFactor_ret); + miqt_exec_callback_QPdfView_zoomFactorChanged(slot, sigval1); + }); +} + +void QPdfView_pageSpacingChanged(QPdfView* self, int pageSpacing) { + self->pageSpacingChanged(static_cast(pageSpacing)); +} + +void QPdfView_connect_pageSpacingChanged(QPdfView* self, intptr_t slot) { + MiqtVirtualQPdfView::connect(self, static_cast(&QPdfView::pageSpacingChanged), self, [=](int pageSpacing) { + int sigval1 = pageSpacing; + miqt_exec_callback_QPdfView_pageSpacingChanged(slot, sigval1); + }); +} + +void QPdfView_documentMarginsChanged(QPdfView* self, QMargins* documentMargins) { + self->documentMarginsChanged(*documentMargins); +} + +void QPdfView_connect_documentMarginsChanged(QPdfView* self, intptr_t slot) { + MiqtVirtualQPdfView::connect(self, static_cast(&QPdfView::documentMarginsChanged), self, [=](QMargins documentMargins) { + QMargins* sigval1 = new QMargins(documentMargins); + miqt_exec_callback_QPdfView_documentMarginsChanged(slot, sigval1); + }); +} + +struct miqt_string QPdfView_tr2(const char* s, const char* c) { + QString _ret = QPdfView::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 QPdfView_tr3(const char* s, const char* c, int n) { + QString _ret = QPdfView::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; +} + +bool QPdfView_override_virtual_paintEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__paintEvent = slot; + return true; +} + +void QPdfView_virtualbase_paintEvent(void* self, QPaintEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::paintEvent(event); + +} + +bool QPdfView_override_virtual_resizeEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__resizeEvent = slot; + return true; +} + +void QPdfView_virtualbase_resizeEvent(void* self, QResizeEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::resizeEvent(event); + +} + +bool QPdfView_override_virtual_scrollContentsBy(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__scrollContentsBy = slot; + return true; +} + +void QPdfView_virtualbase_scrollContentsBy(void* self, int dx, int dy) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::scrollContentsBy(static_cast(dx), static_cast(dy)); + +} + +bool QPdfView_override_virtual_minimumSizeHint(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__minimumSizeHint = slot; + return true; +} + +QSize* QPdfView_virtualbase_minimumSizeHint(const void* self) { + + return new QSize(( (const MiqtVirtualQPdfView*)(self) )->QPdfView::minimumSizeHint()); + +} + +bool QPdfView_override_virtual_sizeHint(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__sizeHint = slot; + return true; +} + +QSize* QPdfView_virtualbase_sizeHint(const void* self) { + + return new QSize(( (const MiqtVirtualQPdfView*)(self) )->QPdfView::sizeHint()); + +} + +bool QPdfView_override_virtual_setupViewport(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setupViewport = slot; + return true; +} + +void QPdfView_virtualbase_setupViewport(void* self, QWidget* viewport) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::setupViewport(viewport); + +} + +bool QPdfView_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QPdfView_virtualbase_eventFilter(void* self, QObject* param1, QEvent* param2) { + + return ( (MiqtVirtualQPdfView*)(self) )->QPdfView::eventFilter(param1, param2); + +} + +bool QPdfView_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QPdfView_virtualbase_event(void* self, QEvent* param1) { + + return ( (MiqtVirtualQPdfView*)(self) )->QPdfView::event(param1); + +} + +bool QPdfView_override_virtual_viewportEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__viewportEvent = slot; + return true; +} + +bool QPdfView_virtualbase_viewportEvent(void* self, QEvent* param1) { + + return ( (MiqtVirtualQPdfView*)(self) )->QPdfView::viewportEvent(param1); + +} + +bool QPdfView_override_virtual_mousePressEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mousePressEvent = slot; + return true; +} + +void QPdfView_virtualbase_mousePressEvent(void* self, QMouseEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::mousePressEvent(param1); + +} + +bool QPdfView_override_virtual_mouseReleaseEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mouseReleaseEvent = slot; + return true; +} + +void QPdfView_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::mouseReleaseEvent(param1); + +} + +bool QPdfView_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mouseDoubleClickEvent = slot; + return true; +} + +void QPdfView_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::mouseDoubleClickEvent(param1); + +} + +bool QPdfView_override_virtual_mouseMoveEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__mouseMoveEvent = slot; + return true; +} + +void QPdfView_virtualbase_mouseMoveEvent(void* self, QMouseEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::mouseMoveEvent(param1); + +} + +bool QPdfView_override_virtual_wheelEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__wheelEvent = slot; + return true; +} + +void QPdfView_virtualbase_wheelEvent(void* self, QWheelEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::wheelEvent(param1); + +} + +bool QPdfView_override_virtual_contextMenuEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__contextMenuEvent = slot; + return true; +} + +void QPdfView_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::contextMenuEvent(param1); + +} + +bool QPdfView_override_virtual_dragEnterEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__dragEnterEvent = slot; + return true; +} + +void QPdfView_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::dragEnterEvent(param1); + +} + +bool QPdfView_override_virtual_dragMoveEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__dragMoveEvent = slot; + return true; +} + +void QPdfView_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::dragMoveEvent(param1); + +} + +bool QPdfView_override_virtual_dragLeaveEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__dragLeaveEvent = slot; + return true; +} + +void QPdfView_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::dragLeaveEvent(param1); + +} + +bool QPdfView_override_virtual_dropEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__dropEvent = slot; + return true; +} + +void QPdfView_virtualbase_dropEvent(void* self, QDropEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::dropEvent(param1); + +} + +bool QPdfView_override_virtual_keyPressEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__keyPressEvent = slot; + return true; +} + +void QPdfView_virtualbase_keyPressEvent(void* self, QKeyEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::keyPressEvent(param1); + +} + +bool QPdfView_override_virtual_viewportSizeHint(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__viewportSizeHint = slot; + return true; +} + +QSize* QPdfView_virtualbase_viewportSizeHint(const void* self) { + + return new QSize(( (const MiqtVirtualQPdfView*)(self) )->QPdfView::viewportSizeHint()); + +} + +bool QPdfView_override_virtual_changeEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__changeEvent = slot; + return true; +} + +void QPdfView_virtualbase_changeEvent(void* self, QEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::changeEvent(param1); + +} + +bool QPdfView_override_virtual_initStyleOption(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__initStyleOption = slot; + return true; +} + +void QPdfView_virtualbase_initStyleOption(const void* self, QStyleOptionFrame* option) { + + ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::initStyleOption(option); + +} + +bool QPdfView_override_virtual_devType(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__devType = slot; + return true; +} + +int QPdfView_virtualbase_devType(const void* self) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::devType(); + +} + +bool QPdfView_override_virtual_setVisible(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setVisible = slot; + return true; +} + +void QPdfView_virtualbase_setVisible(void* self, bool visible) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::setVisible(visible); + +} + +bool QPdfView_override_virtual_heightForWidth(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__heightForWidth = slot; + return true; +} + +int QPdfView_virtualbase_heightForWidth(const void* self, int param1) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::heightForWidth(static_cast(param1)); + +} + +bool QPdfView_override_virtual_hasHeightForWidth(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__hasHeightForWidth = slot; + return true; +} + +bool QPdfView_virtualbase_hasHeightForWidth(const void* self) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::hasHeightForWidth(); + +} + +bool QPdfView_override_virtual_paintEngine(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__paintEngine = slot; + return true; +} + +QPaintEngine* QPdfView_virtualbase_paintEngine(const void* self) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::paintEngine(); + +} + +bool QPdfView_override_virtual_keyReleaseEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__keyReleaseEvent = slot; + return true; +} + +void QPdfView_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::keyReleaseEvent(event); + +} + +bool QPdfView_override_virtual_focusInEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__focusInEvent = slot; + return true; +} + +void QPdfView_virtualbase_focusInEvent(void* self, QFocusEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::focusInEvent(event); + +} + +bool QPdfView_override_virtual_focusOutEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__focusOutEvent = slot; + return true; +} + +void QPdfView_virtualbase_focusOutEvent(void* self, QFocusEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::focusOutEvent(event); + +} + +bool QPdfView_override_virtual_enterEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__enterEvent = slot; + return true; +} + +void QPdfView_virtualbase_enterEvent(void* self, QEnterEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::enterEvent(event); + +} + +bool QPdfView_override_virtual_leaveEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__leaveEvent = slot; + return true; +} + +void QPdfView_virtualbase_leaveEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::leaveEvent(event); + +} + +bool QPdfView_override_virtual_moveEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__moveEvent = slot; + return true; +} + +void QPdfView_virtualbase_moveEvent(void* self, QMoveEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::moveEvent(event); + +} + +bool QPdfView_override_virtual_closeEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__closeEvent = slot; + return true; +} + +void QPdfView_virtualbase_closeEvent(void* self, QCloseEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::closeEvent(event); + +} + +bool QPdfView_override_virtual_tabletEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__tabletEvent = slot; + return true; +} + +void QPdfView_virtualbase_tabletEvent(void* self, QTabletEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::tabletEvent(event); + +} + +bool QPdfView_override_virtual_actionEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__actionEvent = slot; + return true; +} + +void QPdfView_virtualbase_actionEvent(void* self, QActionEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::actionEvent(event); + +} + +bool QPdfView_override_virtual_showEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__showEvent = slot; + return true; +} + +void QPdfView_virtualbase_showEvent(void* self, QShowEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::showEvent(event); + +} + +bool QPdfView_override_virtual_hideEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__hideEvent = slot; + return true; +} + +void QPdfView_virtualbase_hideEvent(void* self, QHideEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::hideEvent(event); + +} + +bool QPdfView_override_virtual_nativeEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__nativeEvent = slot; + return true; +} + +bool QPdfView_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, intptr_t* result) { + QByteArray eventType_QByteArray(eventType.data, eventType.len); + + return ( (MiqtVirtualQPdfView*)(self) )->QPdfView::nativeEvent(eventType_QByteArray, message, (qintptr*)(result)); + +} + +bool QPdfView_override_virtual_metric(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__metric = slot; + return true; +} + +int QPdfView_virtualbase_metric(const void* self, int param1) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::metric(static_cast(param1)); + +} + +bool QPdfView_override_virtual_initPainter(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__initPainter = slot; + return true; +} + +void QPdfView_virtualbase_initPainter(const void* self, QPainter* painter) { + + ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::initPainter(painter); + +} + +bool QPdfView_override_virtual_redirected(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__redirected = slot; + return true; +} + +QPaintDevice* QPdfView_virtualbase_redirected(const void* self, QPoint* offset) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::redirected(offset); + +} + +bool QPdfView_override_virtual_sharedPainter(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__sharedPainter = slot; + return true; +} + +QPainter* QPdfView_virtualbase_sharedPainter(const void* self) { + + return ( (const MiqtVirtualQPdfView*)(self) )->QPdfView::sharedPainter(); + +} + +bool QPdfView_override_virtual_inputMethodEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__inputMethodEvent = slot; + return true; +} + +void QPdfView_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* param1) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::inputMethodEvent(param1); + +} + +bool QPdfView_override_virtual_inputMethodQuery(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__inputMethodQuery = slot; + return true; +} + +QVariant* QPdfView_virtualbase_inputMethodQuery(const void* self, int param1) { + + return new QVariant(( (const MiqtVirtualQPdfView*)(self) )->QPdfView::inputMethodQuery(static_cast(param1))); + +} + +bool QPdfView_override_virtual_focusNextPrevChild(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__focusNextPrevChild = slot; + return true; +} + +bool QPdfView_virtualbase_focusNextPrevChild(void* self, bool next) { + + return ( (MiqtVirtualQPdfView*)(self) )->QPdfView::focusNextPrevChild(next); + +} + +bool QPdfView_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QPdfView_virtualbase_timerEvent(void* self, QTimerEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::timerEvent(event); + +} + +bool QPdfView_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QPdfView_virtualbase_childEvent(void* self, QChildEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::childEvent(event); + +} + +bool QPdfView_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QPdfView_virtualbase_customEvent(void* self, QEvent* event) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::customEvent(event); + +} + +bool QPdfView_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QPdfView_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::connectNotify(*signal); + +} + +bool QPdfView_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QPdfView_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + + ( (MiqtVirtualQPdfView*)(self) )->QPdfView::disconnectNotify(*signal); + +} + +void QPdfView_protectedbase_setViewportMargins(bool* _dynamic_cast_ok, void* self, int left, int top, int right, int bottom) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->setViewportMargins(static_cast(left), static_cast(top), static_cast(right), static_cast(bottom)); + +} + +QMargins* QPdfView_protectedbase_viewportMargins(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return new QMargins(self_cast->viewportMargins()); + +} + +void QPdfView_protectedbase_drawFrame(bool* _dynamic_cast_ok, void* self, QPainter* param1) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->drawFrame(param1); + +} + +void QPdfView_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->updateMicroFocus(); + +} + +void QPdfView_protectedbase_create(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->create(); + +} + +void QPdfView_protectedbase_destroy(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return ; + } + + *_dynamic_cast_ok = true; + + self_cast->destroy(); + +} + +bool QPdfView_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->focusNextChild(); + +} + +bool QPdfView_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->focusPreviousChild(); + +} + +QObject* QPdfView_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + + return self_cast->sender(); + +} + +int QPdfView_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->senderSignalIndex(); + +} + +int QPdfView_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + + return self_cast->receivers(signal); + +} + +bool QPdfView_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQPdfView* self_cast = dynamic_cast( (QPdfView*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + + return self_cast->isSignalConnected(*signal); + +} + +void QPdfView_delete(QPdfView* self) { + delete self; +} + diff --git a/qt6/pdf/gen_qpdfview.go b/qt6/pdf/gen_qpdfview.go new file mode 100644 index 00000000..88fb377d --- /dev/null +++ b/qt6/pdf/gen_qpdfview.go @@ -0,0 +1,1860 @@ +package pdf + +/* + +#include "gen_qpdfview.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QPdfView__PageMode int + +const ( + QPdfView__SinglePage QPdfView__PageMode = 0 + QPdfView__MultiPage QPdfView__PageMode = 1 +) + +type QPdfView__ZoomMode int + +const ( + QPdfView__Custom QPdfView__ZoomMode = 0 + QPdfView__FitToWidth QPdfView__ZoomMode = 1 + QPdfView__FitInView QPdfView__ZoomMode = 2 +) + +type QPdfView struct { + h *C.QPdfView + *qt6.QAbstractScrollArea +} + +func (this *QPdfView) cPointer() *C.QPdfView { + if this == nil { + return nil + } + return this.h +} + +func (this *QPdfView) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQPdfView constructs the type using only CGO pointers. +func newQPdfView(h *C.QPdfView) *QPdfView { + if h == nil { + return nil + } + var outptr_QAbstractScrollArea *C.QAbstractScrollArea = nil + C.QPdfView_virtbase(h, &outptr_QAbstractScrollArea) + + return &QPdfView{h: h, + QAbstractScrollArea: qt6.UnsafeNewQAbstractScrollArea(unsafe.Pointer(outptr_QAbstractScrollArea))} +} + +// UnsafeNewQPdfView constructs the type using only unsafe pointers. +func UnsafeNewQPdfView(h unsafe.Pointer) *QPdfView { + return newQPdfView((*C.QPdfView)(h)) +} + +// NewQPdfView constructs a new QPdfView object. +func NewQPdfView(parent *qt6.QWidget) *QPdfView { + + return newQPdfView(C.QPdfView_new((*C.QWidget)(parent.UnsafePointer()))) +} + +// NewQPdfView2 constructs a new QPdfView object. +func NewQPdfView2() *QPdfView { + + return newQPdfView(C.QPdfView_new2()) +} + +func (this *QPdfView) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QPdfView_metaObject(this.h))) +} + +func (this *QPdfView) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QPdfView_metacast(this.h, param1_Cstring)) +} + +func QPdfView_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QPdfView_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QPdfView) SetDocument(document *QPdfDocument) { + C.QPdfView_setDocument(this.h, document.cPointer()) +} + +func (this *QPdfView) Document() *QPdfDocument { + return newQPdfDocument(C.QPdfView_document(this.h)) +} + +func (this *QPdfView) PageNavigator() *QPdfPageNavigator { + return newQPdfPageNavigator(C.QPdfView_pageNavigator(this.h)) +} + +func (this *QPdfView) PageMode() QPdfView__PageMode { + return (QPdfView__PageMode)(C.QPdfView_pageMode(this.h)) +} + +func (this *QPdfView) ZoomMode() QPdfView__ZoomMode { + return (QPdfView__ZoomMode)(C.QPdfView_zoomMode(this.h)) +} + +func (this *QPdfView) ZoomFactor() float64 { + return (float64)(C.QPdfView_zoomFactor(this.h)) +} + +func (this *QPdfView) PageSpacing() int { + return (int)(C.QPdfView_pageSpacing(this.h)) +} + +func (this *QPdfView) SetPageSpacing(spacing int) { + C.QPdfView_setPageSpacing(this.h, (C.int)(spacing)) +} + +func (this *QPdfView) DocumentMargins() *qt6.QMargins { + _goptr := qt6.UnsafeNewQMargins(unsafe.Pointer(C.QPdfView_documentMargins(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QPdfView) SetDocumentMargins(margins qt6.QMargins) { + C.QPdfView_setDocumentMargins(this.h, (*C.QMargins)(margins.UnsafePointer())) +} + +func (this *QPdfView) SetPageMode(mode QPdfView__PageMode) { + C.QPdfView_setPageMode(this.h, (C.int)(mode)) +} + +func (this *QPdfView) SetZoomMode(mode QPdfView__ZoomMode) { + C.QPdfView_setZoomMode(this.h, (C.int)(mode)) +} + +func (this *QPdfView) SetZoomFactor(factor float64) { + C.QPdfView_setZoomFactor(this.h, (C.double)(factor)) +} + +func (this *QPdfView) DocumentChanged(document *QPdfDocument) { + C.QPdfView_documentChanged(this.h, document.cPointer()) +} +func (this *QPdfView) OnDocumentChanged(slot func(document *QPdfDocument)) { + C.QPdfView_connect_documentChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfView_documentChanged +func miqt_exec_callback_QPdfView_documentChanged(cb C.intptr_t, document *C.QPdfDocument) { + gofunc, ok := cgo.Handle(cb).Value().(func(document *QPdfDocument)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQPdfDocument(document) + + gofunc(slotval1) +} + +func (this *QPdfView) PageModeChanged(pageMode QPdfView__PageMode) { + C.QPdfView_pageModeChanged(this.h, (C.int)(pageMode)) +} +func (this *QPdfView) OnPageModeChanged(slot func(pageMode QPdfView__PageMode)) { + C.QPdfView_connect_pageModeChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfView_pageModeChanged +func miqt_exec_callback_QPdfView_pageModeChanged(cb C.intptr_t, pageMode C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(pageMode QPdfView__PageMode)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (QPdfView__PageMode)(pageMode) + + gofunc(slotval1) +} + +func (this *QPdfView) ZoomModeChanged(zoomMode QPdfView__ZoomMode) { + C.QPdfView_zoomModeChanged(this.h, (C.int)(zoomMode)) +} +func (this *QPdfView) OnZoomModeChanged(slot func(zoomMode QPdfView__ZoomMode)) { + C.QPdfView_connect_zoomModeChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfView_zoomModeChanged +func miqt_exec_callback_QPdfView_zoomModeChanged(cb C.intptr_t, zoomMode C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(zoomMode QPdfView__ZoomMode)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (QPdfView__ZoomMode)(zoomMode) + + gofunc(slotval1) +} + +func (this *QPdfView) ZoomFactorChanged(zoomFactor float64) { + C.QPdfView_zoomFactorChanged(this.h, (C.double)(zoomFactor)) +} +func (this *QPdfView) OnZoomFactorChanged(slot func(zoomFactor float64)) { + C.QPdfView_connect_zoomFactorChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfView_zoomFactorChanged +func miqt_exec_callback_QPdfView_zoomFactorChanged(cb C.intptr_t, zoomFactor C.double) { + gofunc, ok := cgo.Handle(cb).Value().(func(zoomFactor float64)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (float64)(zoomFactor) + + gofunc(slotval1) +} + +func (this *QPdfView) PageSpacingChanged(pageSpacing int) { + C.QPdfView_pageSpacingChanged(this.h, (C.int)(pageSpacing)) +} +func (this *QPdfView) OnPageSpacingChanged(slot func(pageSpacing int)) { + C.QPdfView_connect_pageSpacingChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfView_pageSpacingChanged +func miqt_exec_callback_QPdfView_pageSpacingChanged(cb C.intptr_t, pageSpacing C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(pageSpacing int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(pageSpacing) + + gofunc(slotval1) +} + +func (this *QPdfView) DocumentMarginsChanged(documentMargins qt6.QMargins) { + C.QPdfView_documentMarginsChanged(this.h, (*C.QMargins)(documentMargins.UnsafePointer())) +} +func (this *QPdfView) OnDocumentMarginsChanged(slot func(documentMargins qt6.QMargins)) { + C.QPdfView_connect_documentMarginsChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QPdfView_documentMarginsChanged +func miqt_exec_callback_QPdfView_documentMarginsChanged(cb C.intptr_t, documentMargins *C.QMargins) { + gofunc, ok := cgo.Handle(cb).Value().(func(documentMargins qt6.QMargins)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + documentMargins_goptr := qt6.UnsafeNewQMargins(unsafe.Pointer(documentMargins)) + documentMargins_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + slotval1 := *documentMargins_goptr + + gofunc(slotval1) +} + +func QPdfView_Tr2(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfView_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QPdfView_Tr3(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QPdfView_tr3(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +// SetViewportMargins can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) SetViewportMargins(left int, top int, right int, bottom int) { + + var _dynamic_cast_ok C.bool = false + C.QPdfView_protectedbase_setViewportMargins(&_dynamic_cast_ok, unsafe.Pointer(this.h), (C.int)(left), (C.int)(top), (C.int)(right), (C.int)(bottom)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// ViewportMargins can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) ViewportMargins() qt6.QMargins { + + var _dynamic_cast_ok C.bool = false + _goptr := qt6.UnsafeNewQMargins(unsafe.Pointer(C.QPdfView_protectedbase_viewportMargins(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _method_ret := *_goptr + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// DrawFrame can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) DrawFrame(param1 *qt6.QPainter) { + + var _dynamic_cast_ok C.bool = false + C.QPdfView_protectedbase_drawFrame(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QPainter)(param1.UnsafePointer())) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// UpdateMicroFocus can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) UpdateMicroFocus() { + + var _dynamic_cast_ok C.bool = false + C.QPdfView_protectedbase_updateMicroFocus(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// Create can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) Create() { + + var _dynamic_cast_ok C.bool = false + C.QPdfView_protectedbase_create(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// Destroy can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) Destroy() { + + var _dynamic_cast_ok C.bool = false + C.QPdfView_protectedbase_destroy(&_dynamic_cast_ok, unsafe.Pointer(this.h)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + +} + +// FocusNextChild can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) FocusNextChild() bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfView_protectedbase_focusNextChild(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// FocusPreviousChild can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) FocusPreviousChild() bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfView_protectedbase_focusPreviousChild(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Sender can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QPdfView_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// SenderSignalIndex can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfView_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// Receivers can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) Receivers(signal string) int { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QPdfView_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring)) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +// IsSignalConnected can only be called from a QPdfView that was directly constructed. +func (this *QPdfView) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QPdfView_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))) + + if !_dynamic_cast_ok { + panic("miqt: can only call protected methods for directly constructed types") + } + + return _method_ret + +} + +func (this *QPdfView) callVirtualBase_PaintEvent(event *qt6.QPaintEvent) { + + C.QPdfView_virtualbase_paintEvent(unsafe.Pointer(this.h), (*C.QPaintEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnPaintEvent(slot func(super func(event *qt6.QPaintEvent), event *qt6.QPaintEvent)) { + ok := C.QPdfView_override_virtual_paintEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_paintEvent +func miqt_exec_callback_QPdfView_paintEvent(self *C.QPdfView, cb C.intptr_t, event *C.QPaintEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QPaintEvent), event *qt6.QPaintEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQPaintEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_PaintEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ResizeEvent(event *qt6.QResizeEvent) { + + C.QPdfView_virtualbase_resizeEvent(unsafe.Pointer(this.h), (*C.QResizeEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnResizeEvent(slot func(super func(event *qt6.QResizeEvent), event *qt6.QResizeEvent)) { + ok := C.QPdfView_override_virtual_resizeEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_resizeEvent +func miqt_exec_callback_QPdfView_resizeEvent(self *C.QPdfView, cb C.intptr_t, event *C.QResizeEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QResizeEvent), event *qt6.QResizeEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQResizeEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ResizeEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ScrollContentsBy(dx int, dy int) { + + C.QPdfView_virtualbase_scrollContentsBy(unsafe.Pointer(this.h), (C.int)(dx), (C.int)(dy)) + +} +func (this *QPdfView) OnScrollContentsBy(slot func(super func(dx int, dy int), dx int, dy int)) { + ok := C.QPdfView_override_virtual_scrollContentsBy(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_scrollContentsBy +func miqt_exec_callback_QPdfView_scrollContentsBy(self *C.QPdfView, cb C.intptr_t, dx C.int, dy C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(dx int, dy int), dx int, dy int)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(dx) + + slotval2 := (int)(dy) + + gofunc((&QPdfView{h: self}).callVirtualBase_ScrollContentsBy, slotval1, slotval2) + +} + +func (this *QPdfView) callVirtualBase_MinimumSizeHint() *qt6.QSize { + + _goptr := qt6.UnsafeNewQSize(unsafe.Pointer(C.QPdfView_virtualbase_minimumSizeHint(unsafe.Pointer(this.h)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfView) OnMinimumSizeHint(slot func(super func() *qt6.QSize) *qt6.QSize) { + ok := C.QPdfView_override_virtual_minimumSizeHint(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_minimumSizeHint +func miqt_exec_callback_QPdfView_minimumSizeHint(self *C.QPdfView, cb C.intptr_t) *C.QSize { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *qt6.QSize) *qt6.QSize) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_MinimumSizeHint) + + return (*C.QSize)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_SizeHint() *qt6.QSize { + + _goptr := qt6.UnsafeNewQSize(unsafe.Pointer(C.QPdfView_virtualbase_sizeHint(unsafe.Pointer(this.h)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfView) OnSizeHint(slot func(super func() *qt6.QSize) *qt6.QSize) { + ok := C.QPdfView_override_virtual_sizeHint(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_sizeHint +func miqt_exec_callback_QPdfView_sizeHint(self *C.QPdfView, cb C.intptr_t) *C.QSize { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *qt6.QSize) *qt6.QSize) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_SizeHint) + + return (*C.QSize)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_SetupViewport(viewport *qt6.QWidget) { + + C.QPdfView_virtualbase_setupViewport(unsafe.Pointer(this.h), (*C.QWidget)(viewport.UnsafePointer())) + +} +func (this *QPdfView) OnSetupViewport(slot func(super func(viewport *qt6.QWidget), viewport *qt6.QWidget)) { + ok := C.QPdfView_override_virtual_setupViewport(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_setupViewport +func miqt_exec_callback_QPdfView_setupViewport(self *C.QPdfView, cb C.intptr_t, viewport *C.QWidget) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(viewport *qt6.QWidget), viewport *qt6.QWidget)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQWidget(unsafe.Pointer(viewport)) + + gofunc((&QPdfView{h: self}).callVirtualBase_SetupViewport, slotval1) + +} + +func (this *QPdfView) callVirtualBase_EventFilter(param1 *qt6.QObject, param2 *qt6.QEvent) bool { + + return (bool)(C.QPdfView_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(param1.UnsafePointer()), (*C.QEvent)(param2.UnsafePointer()))) + +} +func (this *QPdfView) OnEventFilter(slot func(super func(param1 *qt6.QObject, param2 *qt6.QEvent) bool, param1 *qt6.QObject, param2 *qt6.QEvent) bool) { + ok := C.QPdfView_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_eventFilter +func miqt_exec_callback_QPdfView_eventFilter(self *C.QPdfView, cb C.intptr_t, param1 *C.QObject, param2 *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QObject, param2 *qt6.QEvent) bool, param1 *qt6.QObject, param2 *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQObject(unsafe.Pointer(param1)) + + slotval2 := qt6.UnsafeNewQEvent(unsafe.Pointer(param2)) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_Event(param1 *qt6.QEvent) bool { + + return (bool)(C.QPdfView_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(param1.UnsafePointer()))) + +} +func (this *QPdfView) OnEvent(slot func(super func(param1 *qt6.QEvent) bool, param1 *qt6.QEvent) bool) { + ok := C.QPdfView_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_event +func miqt_exec_callback_QPdfView_event(self *C.QPdfView, cb C.intptr_t, param1 *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QEvent) bool, param1 *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(param1)) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_ViewportEvent(param1 *qt6.QEvent) bool { + + return (bool)(C.QPdfView_virtualbase_viewportEvent(unsafe.Pointer(this.h), (*C.QEvent)(param1.UnsafePointer()))) + +} +func (this *QPdfView) OnViewportEvent(slot func(super func(param1 *qt6.QEvent) bool, param1 *qt6.QEvent) bool) { + ok := C.QPdfView_override_virtual_viewportEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_viewportEvent +func miqt_exec_callback_QPdfView_viewportEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QEvent) bool, param1 *qt6.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(param1)) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_ViewportEvent, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_MousePressEvent(param1 *qt6.QMouseEvent) { + + C.QPdfView_virtualbase_mousePressEvent(unsafe.Pointer(this.h), (*C.QMouseEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnMousePressEvent(slot func(super func(param1 *qt6.QMouseEvent), param1 *qt6.QMouseEvent)) { + ok := C.QPdfView_override_virtual_mousePressEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_mousePressEvent +func miqt_exec_callback_QPdfView_mousePressEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QMouseEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QMouseEvent), param1 *qt6.QMouseEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMouseEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_MousePressEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_MouseReleaseEvent(param1 *qt6.QMouseEvent) { + + C.QPdfView_virtualbase_mouseReleaseEvent(unsafe.Pointer(this.h), (*C.QMouseEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnMouseReleaseEvent(slot func(super func(param1 *qt6.QMouseEvent), param1 *qt6.QMouseEvent)) { + ok := C.QPdfView_override_virtual_mouseReleaseEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_mouseReleaseEvent +func miqt_exec_callback_QPdfView_mouseReleaseEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QMouseEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QMouseEvent), param1 *qt6.QMouseEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMouseEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_MouseReleaseEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_MouseDoubleClickEvent(param1 *qt6.QMouseEvent) { + + C.QPdfView_virtualbase_mouseDoubleClickEvent(unsafe.Pointer(this.h), (*C.QMouseEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnMouseDoubleClickEvent(slot func(super func(param1 *qt6.QMouseEvent), param1 *qt6.QMouseEvent)) { + ok := C.QPdfView_override_virtual_mouseDoubleClickEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_mouseDoubleClickEvent +func miqt_exec_callback_QPdfView_mouseDoubleClickEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QMouseEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QMouseEvent), param1 *qt6.QMouseEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMouseEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_MouseDoubleClickEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_MouseMoveEvent(param1 *qt6.QMouseEvent) { + + C.QPdfView_virtualbase_mouseMoveEvent(unsafe.Pointer(this.h), (*C.QMouseEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnMouseMoveEvent(slot func(super func(param1 *qt6.QMouseEvent), param1 *qt6.QMouseEvent)) { + ok := C.QPdfView_override_virtual_mouseMoveEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_mouseMoveEvent +func miqt_exec_callback_QPdfView_mouseMoveEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QMouseEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QMouseEvent), param1 *qt6.QMouseEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMouseEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_MouseMoveEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_WheelEvent(param1 *qt6.QWheelEvent) { + + C.QPdfView_virtualbase_wheelEvent(unsafe.Pointer(this.h), (*C.QWheelEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnWheelEvent(slot func(super func(param1 *qt6.QWheelEvent), param1 *qt6.QWheelEvent)) { + ok := C.QPdfView_override_virtual_wheelEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_wheelEvent +func miqt_exec_callback_QPdfView_wheelEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QWheelEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QWheelEvent), param1 *qt6.QWheelEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQWheelEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_WheelEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ContextMenuEvent(param1 *qt6.QContextMenuEvent) { + + C.QPdfView_virtualbase_contextMenuEvent(unsafe.Pointer(this.h), (*C.QContextMenuEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnContextMenuEvent(slot func(super func(param1 *qt6.QContextMenuEvent), param1 *qt6.QContextMenuEvent)) { + ok := C.QPdfView_override_virtual_contextMenuEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_contextMenuEvent +func miqt_exec_callback_QPdfView_contextMenuEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QContextMenuEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QContextMenuEvent), param1 *qt6.QContextMenuEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQContextMenuEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ContextMenuEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_DragEnterEvent(param1 *qt6.QDragEnterEvent) { + + C.QPdfView_virtualbase_dragEnterEvent(unsafe.Pointer(this.h), (*C.QDragEnterEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnDragEnterEvent(slot func(super func(param1 *qt6.QDragEnterEvent), param1 *qt6.QDragEnterEvent)) { + ok := C.QPdfView_override_virtual_dragEnterEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_dragEnterEvent +func miqt_exec_callback_QPdfView_dragEnterEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QDragEnterEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QDragEnterEvent), param1 *qt6.QDragEnterEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQDragEnterEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_DragEnterEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_DragMoveEvent(param1 *qt6.QDragMoveEvent) { + + C.QPdfView_virtualbase_dragMoveEvent(unsafe.Pointer(this.h), (*C.QDragMoveEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnDragMoveEvent(slot func(super func(param1 *qt6.QDragMoveEvent), param1 *qt6.QDragMoveEvent)) { + ok := C.QPdfView_override_virtual_dragMoveEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_dragMoveEvent +func miqt_exec_callback_QPdfView_dragMoveEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QDragMoveEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QDragMoveEvent), param1 *qt6.QDragMoveEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQDragMoveEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_DragMoveEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_DragLeaveEvent(param1 *qt6.QDragLeaveEvent) { + + C.QPdfView_virtualbase_dragLeaveEvent(unsafe.Pointer(this.h), (*C.QDragLeaveEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnDragLeaveEvent(slot func(super func(param1 *qt6.QDragLeaveEvent), param1 *qt6.QDragLeaveEvent)) { + ok := C.QPdfView_override_virtual_dragLeaveEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_dragLeaveEvent +func miqt_exec_callback_QPdfView_dragLeaveEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QDragLeaveEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QDragLeaveEvent), param1 *qt6.QDragLeaveEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQDragLeaveEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_DragLeaveEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_DropEvent(param1 *qt6.QDropEvent) { + + C.QPdfView_virtualbase_dropEvent(unsafe.Pointer(this.h), (*C.QDropEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnDropEvent(slot func(super func(param1 *qt6.QDropEvent), param1 *qt6.QDropEvent)) { + ok := C.QPdfView_override_virtual_dropEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_dropEvent +func miqt_exec_callback_QPdfView_dropEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QDropEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QDropEvent), param1 *qt6.QDropEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQDropEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_DropEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_KeyPressEvent(param1 *qt6.QKeyEvent) { + + C.QPdfView_virtualbase_keyPressEvent(unsafe.Pointer(this.h), (*C.QKeyEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnKeyPressEvent(slot func(super func(param1 *qt6.QKeyEvent), param1 *qt6.QKeyEvent)) { + ok := C.QPdfView_override_virtual_keyPressEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_keyPressEvent +func miqt_exec_callback_QPdfView_keyPressEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QKeyEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QKeyEvent), param1 *qt6.QKeyEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQKeyEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_KeyPressEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ViewportSizeHint() *qt6.QSize { + + _goptr := qt6.UnsafeNewQSize(unsafe.Pointer(C.QPdfView_virtualbase_viewportSizeHint(unsafe.Pointer(this.h)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfView) OnViewportSizeHint(slot func(super func() *qt6.QSize) *qt6.QSize) { + ok := C.QPdfView_override_virtual_viewportSizeHint(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_viewportSizeHint +func miqt_exec_callback_QPdfView_viewportSizeHint(self *C.QPdfView, cb C.intptr_t) *C.QSize { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *qt6.QSize) *qt6.QSize) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_ViewportSizeHint) + + return (*C.QSize)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_ChangeEvent(param1 *qt6.QEvent) { + + C.QPdfView_virtualbase_changeEvent(unsafe.Pointer(this.h), (*C.QEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnChangeEvent(slot func(super func(param1 *qt6.QEvent), param1 *qt6.QEvent)) { + ok := C.QPdfView_override_virtual_changeEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_changeEvent +func miqt_exec_callback_QPdfView_changeEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QEvent), param1 *qt6.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ChangeEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_InitStyleOption(option *qt6.QStyleOptionFrame) { + + C.QPdfView_virtualbase_initStyleOption(unsafe.Pointer(this.h), (*C.QStyleOptionFrame)(option.UnsafePointer())) + +} +func (this *QPdfView) OnInitStyleOption(slot func(super func(option *qt6.QStyleOptionFrame), option *qt6.QStyleOptionFrame)) { + ok := C.QPdfView_override_virtual_initStyleOption(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_initStyleOption +func miqt_exec_callback_QPdfView_initStyleOption(self *C.QPdfView, cb C.intptr_t, option *C.QStyleOptionFrame) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(option *qt6.QStyleOptionFrame), option *qt6.QStyleOptionFrame)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQStyleOptionFrame(unsafe.Pointer(option)) + + gofunc((&QPdfView{h: self}).callVirtualBase_InitStyleOption, slotval1) + +} + +func (this *QPdfView) callVirtualBase_DevType() int { + + return (int)(C.QPdfView_virtualbase_devType(unsafe.Pointer(this.h))) + +} +func (this *QPdfView) OnDevType(slot func(super func() int) int) { + ok := C.QPdfView_override_virtual_devType(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_devType +func miqt_exec_callback_QPdfView_devType(self *C.QPdfView, cb C.intptr_t) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_DevType) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_SetVisible(visible bool) { + + C.QPdfView_virtualbase_setVisible(unsafe.Pointer(this.h), (C.bool)(visible)) + +} +func (this *QPdfView) OnSetVisible(slot func(super func(visible bool), visible bool)) { + ok := C.QPdfView_override_virtual_setVisible(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_setVisible +func miqt_exec_callback_QPdfView_setVisible(self *C.QPdfView, cb C.intptr_t, visible C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(visible bool), visible bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(visible) + + gofunc((&QPdfView{h: self}).callVirtualBase_SetVisible, slotval1) + +} + +func (this *QPdfView) callVirtualBase_HeightForWidth(param1 int) int { + + return (int)(C.QPdfView_virtualbase_heightForWidth(unsafe.Pointer(this.h), (C.int)(param1))) + +} +func (this *QPdfView) OnHeightForWidth(slot func(super func(param1 int) int, param1 int) int) { + ok := C.QPdfView_override_virtual_heightForWidth(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_heightForWidth +func miqt_exec_callback_QPdfView_heightForWidth(self *C.QPdfView, cb C.intptr_t, param1 C.int) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 int) int, param1 int) int) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(param1) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_HeightForWidth, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_HasHeightForWidth() bool { + + return (bool)(C.QPdfView_virtualbase_hasHeightForWidth(unsafe.Pointer(this.h))) + +} +func (this *QPdfView) OnHasHeightForWidth(slot func(super func() bool) bool) { + ok := C.QPdfView_override_virtual_hasHeightForWidth(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_hasHeightForWidth +func miqt_exec_callback_QPdfView_hasHeightForWidth(self *C.QPdfView, cb C.intptr_t) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_HasHeightForWidth) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_PaintEngine() *qt6.QPaintEngine { + + return qt6.UnsafeNewQPaintEngine(unsafe.Pointer(C.QPdfView_virtualbase_paintEngine(unsafe.Pointer(this.h)))) + +} +func (this *QPdfView) OnPaintEngine(slot func(super func() *qt6.QPaintEngine) *qt6.QPaintEngine) { + ok := C.QPdfView_override_virtual_paintEngine(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_paintEngine +func miqt_exec_callback_QPdfView_paintEngine(self *C.QPdfView, cb C.intptr_t) *C.QPaintEngine { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *qt6.QPaintEngine) *qt6.QPaintEngine) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_PaintEngine) + + return (*C.QPaintEngine)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_KeyReleaseEvent(event *qt6.QKeyEvent) { + + C.QPdfView_virtualbase_keyReleaseEvent(unsafe.Pointer(this.h), (*C.QKeyEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnKeyReleaseEvent(slot func(super func(event *qt6.QKeyEvent), event *qt6.QKeyEvent)) { + ok := C.QPdfView_override_virtual_keyReleaseEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_keyReleaseEvent +func miqt_exec_callback_QPdfView_keyReleaseEvent(self *C.QPdfView, cb C.intptr_t, event *C.QKeyEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QKeyEvent), event *qt6.QKeyEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQKeyEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_KeyReleaseEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_FocusInEvent(event *qt6.QFocusEvent) { + + C.QPdfView_virtualbase_focusInEvent(unsafe.Pointer(this.h), (*C.QFocusEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnFocusInEvent(slot func(super func(event *qt6.QFocusEvent), event *qt6.QFocusEvent)) { + ok := C.QPdfView_override_virtual_focusInEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_focusInEvent +func miqt_exec_callback_QPdfView_focusInEvent(self *C.QPdfView, cb C.intptr_t, event *C.QFocusEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QFocusEvent), event *qt6.QFocusEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQFocusEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_FocusInEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_FocusOutEvent(event *qt6.QFocusEvent) { + + C.QPdfView_virtualbase_focusOutEvent(unsafe.Pointer(this.h), (*C.QFocusEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnFocusOutEvent(slot func(super func(event *qt6.QFocusEvent), event *qt6.QFocusEvent)) { + ok := C.QPdfView_override_virtual_focusOutEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_focusOutEvent +func miqt_exec_callback_QPdfView_focusOutEvent(self *C.QPdfView, cb C.intptr_t, event *C.QFocusEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QFocusEvent), event *qt6.QFocusEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQFocusEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_FocusOutEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_EnterEvent(event *qt6.QEnterEvent) { + + C.QPdfView_virtualbase_enterEvent(unsafe.Pointer(this.h), (*C.QEnterEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnEnterEvent(slot func(super func(event *qt6.QEnterEvent), event *qt6.QEnterEvent)) { + ok := C.QPdfView_override_virtual_enterEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_enterEvent +func miqt_exec_callback_QPdfView_enterEvent(self *C.QPdfView, cb C.intptr_t, event *C.QEnterEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEnterEvent), event *qt6.QEnterEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEnterEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_EnterEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_LeaveEvent(event *qt6.QEvent) { + + C.QPdfView_virtualbase_leaveEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnLeaveEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QPdfView_override_virtual_leaveEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_leaveEvent +func miqt_exec_callback_QPdfView_leaveEvent(self *C.QPdfView, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent), event *qt6.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_LeaveEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_MoveEvent(event *qt6.QMoveEvent) { + + C.QPdfView_virtualbase_moveEvent(unsafe.Pointer(this.h), (*C.QMoveEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnMoveEvent(slot func(super func(event *qt6.QMoveEvent), event *qt6.QMoveEvent)) { + ok := C.QPdfView_override_virtual_moveEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_moveEvent +func miqt_exec_callback_QPdfView_moveEvent(self *C.QPdfView, cb C.intptr_t, event *C.QMoveEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QMoveEvent), event *qt6.QMoveEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMoveEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_MoveEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_CloseEvent(event *qt6.QCloseEvent) { + + C.QPdfView_virtualbase_closeEvent(unsafe.Pointer(this.h), (*C.QCloseEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnCloseEvent(slot func(super func(event *qt6.QCloseEvent), event *qt6.QCloseEvent)) { + ok := C.QPdfView_override_virtual_closeEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_closeEvent +func miqt_exec_callback_QPdfView_closeEvent(self *C.QPdfView, cb C.intptr_t, event *C.QCloseEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QCloseEvent), event *qt6.QCloseEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQCloseEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_CloseEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_TabletEvent(event *qt6.QTabletEvent) { + + C.QPdfView_virtualbase_tabletEvent(unsafe.Pointer(this.h), (*C.QTabletEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnTabletEvent(slot func(super func(event *qt6.QTabletEvent), event *qt6.QTabletEvent)) { + ok := C.QPdfView_override_virtual_tabletEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_tabletEvent +func miqt_exec_callback_QPdfView_tabletEvent(self *C.QPdfView, cb C.intptr_t, event *C.QTabletEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QTabletEvent), event *qt6.QTabletEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQTabletEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_TabletEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ActionEvent(event *qt6.QActionEvent) { + + C.QPdfView_virtualbase_actionEvent(unsafe.Pointer(this.h), (*C.QActionEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnActionEvent(slot func(super func(event *qt6.QActionEvent), event *qt6.QActionEvent)) { + ok := C.QPdfView_override_virtual_actionEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_actionEvent +func miqt_exec_callback_QPdfView_actionEvent(self *C.QPdfView, cb C.intptr_t, event *C.QActionEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QActionEvent), event *qt6.QActionEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQActionEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ActionEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ShowEvent(event *qt6.QShowEvent) { + + C.QPdfView_virtualbase_showEvent(unsafe.Pointer(this.h), (*C.QShowEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnShowEvent(slot func(super func(event *qt6.QShowEvent), event *qt6.QShowEvent)) { + ok := C.QPdfView_override_virtual_showEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_showEvent +func miqt_exec_callback_QPdfView_showEvent(self *C.QPdfView, cb C.intptr_t, event *C.QShowEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QShowEvent), event *qt6.QShowEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQShowEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ShowEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_HideEvent(event *qt6.QHideEvent) { + + C.QPdfView_virtualbase_hideEvent(unsafe.Pointer(this.h), (*C.QHideEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnHideEvent(slot func(super func(event *qt6.QHideEvent), event *qt6.QHideEvent)) { + ok := C.QPdfView_override_virtual_hideEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_hideEvent +func miqt_exec_callback_QPdfView_hideEvent(self *C.QPdfView, cb C.intptr_t, event *C.QHideEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QHideEvent), event *qt6.QHideEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQHideEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_HideEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_NativeEvent(eventType []byte, message unsafe.Pointer, result *uintptr) bool { + eventType_alias := C.struct_miqt_string{} + if len(eventType) > 0 { + eventType_alias.data = (*C.char)(unsafe.Pointer(&eventType[0])) + } else { + eventType_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + eventType_alias.len = C.size_t(len(eventType)) + + return (bool)(C.QPdfView_virtualbase_nativeEvent(unsafe.Pointer(this.h), eventType_alias, message, (*C.intptr_t)(unsafe.Pointer(result)))) + +} +func (this *QPdfView) OnNativeEvent(slot func(super func(eventType []byte, message unsafe.Pointer, result *uintptr) bool, eventType []byte, message unsafe.Pointer, result *uintptr) bool) { + ok := C.QPdfView_override_virtual_nativeEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_nativeEvent +func miqt_exec_callback_QPdfView_nativeEvent(self *C.QPdfView, cb C.intptr_t, eventType C.struct_miqt_string, message unsafe.Pointer, result *C.intptr_t) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(eventType []byte, message unsafe.Pointer, result *uintptr) bool, eventType []byte, message unsafe.Pointer, result *uintptr) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var eventType_bytearray C.struct_miqt_string = eventType + eventType_ret := C.GoBytes(unsafe.Pointer(eventType_bytearray.data), C.int(int64(eventType_bytearray.len))) + C.free(unsafe.Pointer(eventType_bytearray.data)) + slotval1 := eventType_ret + slotval2 := (unsafe.Pointer)(message) + + slotval3 := (*uintptr)(unsafe.Pointer(result)) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_NativeEvent, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_Metric(param1 qt6.QPaintDevice__PaintDeviceMetric) int { + + return (int)(C.QPdfView_virtualbase_metric(unsafe.Pointer(this.h), (C.int)(param1))) + +} +func (this *QPdfView) OnMetric(slot func(super func(param1 qt6.QPaintDevice__PaintDeviceMetric) int, param1 qt6.QPaintDevice__PaintDeviceMetric) int) { + ok := C.QPdfView_override_virtual_metric(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_metric +func miqt_exec_callback_QPdfView_metric(self *C.QPdfView, cb C.intptr_t, param1 C.int) C.int { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 qt6.QPaintDevice__PaintDeviceMetric) int, param1 qt6.QPaintDevice__PaintDeviceMetric) int) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (qt6.QPaintDevice__PaintDeviceMetric)(param1) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_Metric, slotval1) + + return (C.int)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_InitPainter(painter *qt6.QPainter) { + + C.QPdfView_virtualbase_initPainter(unsafe.Pointer(this.h), (*C.QPainter)(painter.UnsafePointer())) + +} +func (this *QPdfView) OnInitPainter(slot func(super func(painter *qt6.QPainter), painter *qt6.QPainter)) { + ok := C.QPdfView_override_virtual_initPainter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_initPainter +func miqt_exec_callback_QPdfView_initPainter(self *C.QPdfView, cb C.intptr_t, painter *C.QPainter) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(painter *qt6.QPainter), painter *qt6.QPainter)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQPainter(unsafe.Pointer(painter)) + + gofunc((&QPdfView{h: self}).callVirtualBase_InitPainter, slotval1) + +} + +func (this *QPdfView) callVirtualBase_Redirected(offset *qt6.QPoint) *qt6.QPaintDevice { + + return qt6.UnsafeNewQPaintDevice(unsafe.Pointer(C.QPdfView_virtualbase_redirected(unsafe.Pointer(this.h), (*C.QPoint)(offset.UnsafePointer())))) + +} +func (this *QPdfView) OnRedirected(slot func(super func(offset *qt6.QPoint) *qt6.QPaintDevice, offset *qt6.QPoint) *qt6.QPaintDevice) { + ok := C.QPdfView_override_virtual_redirected(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_redirected +func miqt_exec_callback_QPdfView_redirected(self *C.QPdfView, cb C.intptr_t, offset *C.QPoint) *C.QPaintDevice { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(offset *qt6.QPoint) *qt6.QPaintDevice, offset *qt6.QPoint) *qt6.QPaintDevice) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQPoint(unsafe.Pointer(offset)) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_Redirected, slotval1) + + return (*C.QPaintDevice)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_SharedPainter() *qt6.QPainter { + + return qt6.UnsafeNewQPainter(unsafe.Pointer(C.QPdfView_virtualbase_sharedPainter(unsafe.Pointer(this.h)))) + +} +func (this *QPdfView) OnSharedPainter(slot func(super func() *qt6.QPainter) *qt6.QPainter) { + ok := C.QPdfView_override_virtual_sharedPainter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_sharedPainter +func miqt_exec_callback_QPdfView_sharedPainter(self *C.QPdfView, cb C.intptr_t) *C.QPainter { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *qt6.QPainter) *qt6.QPainter) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_SharedPainter) + + return (*C.QPainter)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_InputMethodEvent(param1 *qt6.QInputMethodEvent) { + + C.QPdfView_virtualbase_inputMethodEvent(unsafe.Pointer(this.h), (*C.QInputMethodEvent)(param1.UnsafePointer())) + +} +func (this *QPdfView) OnInputMethodEvent(slot func(super func(param1 *qt6.QInputMethodEvent), param1 *qt6.QInputMethodEvent)) { + ok := C.QPdfView_override_virtual_inputMethodEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_inputMethodEvent +func miqt_exec_callback_QPdfView_inputMethodEvent(self *C.QPdfView, cb C.intptr_t, param1 *C.QInputMethodEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt6.QInputMethodEvent), param1 *qt6.QInputMethodEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQInputMethodEvent(unsafe.Pointer(param1)) + + gofunc((&QPdfView{h: self}).callVirtualBase_InputMethodEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_InputMethodQuery(param1 qt6.InputMethodQuery) *qt6.QVariant { + + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QPdfView_virtualbase_inputMethodQuery(unsafe.Pointer(this.h), (C.int)(param1)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QPdfView) OnInputMethodQuery(slot func(super func(param1 qt6.InputMethodQuery) *qt6.QVariant, param1 qt6.InputMethodQuery) *qt6.QVariant) { + ok := C.QPdfView_override_virtual_inputMethodQuery(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_inputMethodQuery +func miqt_exec_callback_QPdfView_inputMethodQuery(self *C.QPdfView, cb C.intptr_t, param1 C.int) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 qt6.InputMethodQuery) *qt6.QVariant, param1 qt6.InputMethodQuery) *qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (qt6.InputMethodQuery)(param1) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_InputMethodQuery, slotval1) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QPdfView) callVirtualBase_FocusNextPrevChild(next bool) bool { + + return (bool)(C.QPdfView_virtualbase_focusNextPrevChild(unsafe.Pointer(this.h), (C.bool)(next))) + +} +func (this *QPdfView) OnFocusNextPrevChild(slot func(super func(next bool) bool, next bool) bool) { + ok := C.QPdfView_override_virtual_focusNextPrevChild(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_focusNextPrevChild +func miqt_exec_callback_QPdfView_focusNextPrevChild(self *C.QPdfView, cb C.intptr_t, next C.bool) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(next bool) bool, next bool) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(next) + + virtualReturn := gofunc((&QPdfView{h: self}).callVirtualBase_FocusNextPrevChild, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QPdfView) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QPdfView_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QPdfView_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_timerEvent +func miqt_exec_callback_QPdfView_timerEvent(self *C.QPdfView, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QPdfView_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QPdfView_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_childEvent +func miqt_exec_callback_QPdfView_childEvent(self *C.QPdfView, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QPdfView_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QPdfView) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QPdfView_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_customEvent +func miqt_exec_callback_QPdfView_customEvent(self *C.QPdfView, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent), event *qt6.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QPdfView{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QPdfView) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QPdfView_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfView) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QPdfView_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_connectNotify +func miqt_exec_callback_QPdfView_connectNotify(self *C.QPdfView, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfView{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QPdfView) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QPdfView_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QPdfView) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QPdfView_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QPdfView_disconnectNotify +func miqt_exec_callback_QPdfView_disconnectNotify(self *C.QPdfView, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QPdfView{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QPdfView) Delete() { + C.QPdfView_delete(this.h) +} + +// GoGC adds a Go Finalizer to this pointer, so that it will be deleted +// from C++ memory once it is unreachable from Go memory. +func (this *QPdfView) GoGC() { + runtime.SetFinalizer(this, func(this *QPdfView) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/pdf/gen_qpdfview.h b/qt6/pdf/gen_qpdfview.h new file mode 100644 index 00000000..de90f87e --- /dev/null +++ b/qt6/pdf/gen_qpdfview.h @@ -0,0 +1,257 @@ +#pragma once +#ifndef MIQT_QT6_PDF_GEN_QPDFVIEW_H +#define MIQT_QT6_PDF_GEN_QPDFVIEW_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractScrollArea; +class QActionEvent; +class QChildEvent; +class QCloseEvent; +class QContextMenuEvent; +class QDragEnterEvent; +class QDragLeaveEvent; +class QDragMoveEvent; +class QDropEvent; +class QEnterEvent; +class QEvent; +class QFocusEvent; +class QFrame; +class QHideEvent; +class QInputMethodEvent; +class QKeyEvent; +class QMargins; +class QMetaMethod; +class QMetaObject; +class QMouseEvent; +class QMoveEvent; +class QObject; +class QPaintDevice; +class QPaintEngine; +class QPaintEvent; +class QPainter; +class QPdfDocument; +class QPdfPageNavigator; +class QPdfView; +class QPoint; +class QResizeEvent; +class QShowEvent; +class QSize; +class QStyleOptionFrame; +class QTabletEvent; +class QTimerEvent; +class QVariant; +class QWheelEvent; +class QWidget; +#else +typedef struct QAbstractScrollArea QAbstractScrollArea; +typedef struct QActionEvent QActionEvent; +typedef struct QChildEvent QChildEvent; +typedef struct QCloseEvent QCloseEvent; +typedef struct QContextMenuEvent QContextMenuEvent; +typedef struct QDragEnterEvent QDragEnterEvent; +typedef struct QDragLeaveEvent QDragLeaveEvent; +typedef struct QDragMoveEvent QDragMoveEvent; +typedef struct QDropEvent QDropEvent; +typedef struct QEnterEvent QEnterEvent; +typedef struct QEvent QEvent; +typedef struct QFocusEvent QFocusEvent; +typedef struct QFrame QFrame; +typedef struct QHideEvent QHideEvent; +typedef struct QInputMethodEvent QInputMethodEvent; +typedef struct QKeyEvent QKeyEvent; +typedef struct QMargins QMargins; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QMouseEvent QMouseEvent; +typedef struct QMoveEvent QMoveEvent; +typedef struct QObject QObject; +typedef struct QPaintDevice QPaintDevice; +typedef struct QPaintEngine QPaintEngine; +typedef struct QPaintEvent QPaintEvent; +typedef struct QPainter QPainter; +typedef struct QPdfDocument QPdfDocument; +typedef struct QPdfPageNavigator QPdfPageNavigator; +typedef struct QPdfView QPdfView; +typedef struct QPoint QPoint; +typedef struct QResizeEvent QResizeEvent; +typedef struct QShowEvent QShowEvent; +typedef struct QSize QSize; +typedef struct QStyleOptionFrame QStyleOptionFrame; +typedef struct QTabletEvent QTabletEvent; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +typedef struct QWheelEvent QWheelEvent; +typedef struct QWidget QWidget; +#endif + +QPdfView* QPdfView_new(QWidget* parent); +QPdfView* QPdfView_new2(); +void QPdfView_virtbase(QPdfView* src, QAbstractScrollArea** outptr_QAbstractScrollArea); +QMetaObject* QPdfView_metaObject(const QPdfView* self); +void* QPdfView_metacast(QPdfView* self, const char* param1); +struct miqt_string QPdfView_tr(const char* s); +void QPdfView_setDocument(QPdfView* self, QPdfDocument* document); +QPdfDocument* QPdfView_document(const QPdfView* self); +QPdfPageNavigator* QPdfView_pageNavigator(const QPdfView* self); +int QPdfView_pageMode(const QPdfView* self); +int QPdfView_zoomMode(const QPdfView* self); +double QPdfView_zoomFactor(const QPdfView* self); +int QPdfView_pageSpacing(const QPdfView* self); +void QPdfView_setPageSpacing(QPdfView* self, int spacing); +QMargins* QPdfView_documentMargins(const QPdfView* self); +void QPdfView_setDocumentMargins(QPdfView* self, QMargins* margins); +void QPdfView_setPageMode(QPdfView* self, int mode); +void QPdfView_setZoomMode(QPdfView* self, int mode); +void QPdfView_setZoomFactor(QPdfView* self, double factor); +void QPdfView_documentChanged(QPdfView* self, QPdfDocument* document); +void QPdfView_connect_documentChanged(QPdfView* self, intptr_t slot); +void QPdfView_pageModeChanged(QPdfView* self, int pageMode); +void QPdfView_connect_pageModeChanged(QPdfView* self, intptr_t slot); +void QPdfView_zoomModeChanged(QPdfView* self, int zoomMode); +void QPdfView_connect_zoomModeChanged(QPdfView* self, intptr_t slot); +void QPdfView_zoomFactorChanged(QPdfView* self, double zoomFactor); +void QPdfView_connect_zoomFactorChanged(QPdfView* self, intptr_t slot); +void QPdfView_pageSpacingChanged(QPdfView* self, int pageSpacing); +void QPdfView_connect_pageSpacingChanged(QPdfView* self, intptr_t slot); +void QPdfView_documentMarginsChanged(QPdfView* self, QMargins* documentMargins); +void QPdfView_connect_documentMarginsChanged(QPdfView* self, intptr_t slot); +void QPdfView_paintEvent(QPdfView* self, QPaintEvent* event); +void QPdfView_resizeEvent(QPdfView* self, QResizeEvent* event); +void QPdfView_scrollContentsBy(QPdfView* self, int dx, int dy); +struct miqt_string QPdfView_tr2(const char* s, const char* c); +struct miqt_string QPdfView_tr3(const char* s, const char* c, int n); +bool QPdfView_override_virtual_paintEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_paintEvent(void* self, QPaintEvent* event); +bool QPdfView_override_virtual_resizeEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_resizeEvent(void* self, QResizeEvent* event); +bool QPdfView_override_virtual_scrollContentsBy(void* self, intptr_t slot); +void QPdfView_virtualbase_scrollContentsBy(void* self, int dx, int dy); +bool QPdfView_override_virtual_minimumSizeHint(void* self, intptr_t slot); +QSize* QPdfView_virtualbase_minimumSizeHint(const void* self); +bool QPdfView_override_virtual_sizeHint(void* self, intptr_t slot); +QSize* QPdfView_virtualbase_sizeHint(const void* self); +bool QPdfView_override_virtual_setupViewport(void* self, intptr_t slot); +void QPdfView_virtualbase_setupViewport(void* self, QWidget* viewport); +bool QPdfView_override_virtual_eventFilter(void* self, intptr_t slot); +bool QPdfView_virtualbase_eventFilter(void* self, QObject* param1, QEvent* param2); +bool QPdfView_override_virtual_event(void* self, intptr_t slot); +bool QPdfView_virtualbase_event(void* self, QEvent* param1); +bool QPdfView_override_virtual_viewportEvent(void* self, intptr_t slot); +bool QPdfView_virtualbase_viewportEvent(void* self, QEvent* param1); +bool QPdfView_override_virtual_mousePressEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_mousePressEvent(void* self, QMouseEvent* param1); +bool QPdfView_override_virtual_mouseReleaseEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* param1); +bool QPdfView_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* param1); +bool QPdfView_override_virtual_mouseMoveEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_mouseMoveEvent(void* self, QMouseEvent* param1); +bool QPdfView_override_virtual_wheelEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_wheelEvent(void* self, QWheelEvent* param1); +bool QPdfView_override_virtual_contextMenuEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* param1); +bool QPdfView_override_virtual_dragEnterEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* param1); +bool QPdfView_override_virtual_dragMoveEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* param1); +bool QPdfView_override_virtual_dragLeaveEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* param1); +bool QPdfView_override_virtual_dropEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_dropEvent(void* self, QDropEvent* param1); +bool QPdfView_override_virtual_keyPressEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_keyPressEvent(void* self, QKeyEvent* param1); +bool QPdfView_override_virtual_viewportSizeHint(void* self, intptr_t slot); +QSize* QPdfView_virtualbase_viewportSizeHint(const void* self); +bool QPdfView_override_virtual_changeEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_changeEvent(void* self, QEvent* param1); +bool QPdfView_override_virtual_initStyleOption(void* self, intptr_t slot); +void QPdfView_virtualbase_initStyleOption(const void* self, QStyleOptionFrame* option); +bool QPdfView_override_virtual_devType(void* self, intptr_t slot); +int QPdfView_virtualbase_devType(const void* self); +bool QPdfView_override_virtual_setVisible(void* self, intptr_t slot); +void QPdfView_virtualbase_setVisible(void* self, bool visible); +bool QPdfView_override_virtual_heightForWidth(void* self, intptr_t slot); +int QPdfView_virtualbase_heightForWidth(const void* self, int param1); +bool QPdfView_override_virtual_hasHeightForWidth(void* self, intptr_t slot); +bool QPdfView_virtualbase_hasHeightForWidth(const void* self); +bool QPdfView_override_virtual_paintEngine(void* self, intptr_t slot); +QPaintEngine* QPdfView_virtualbase_paintEngine(const void* self); +bool QPdfView_override_virtual_keyReleaseEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event); +bool QPdfView_override_virtual_focusInEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_focusInEvent(void* self, QFocusEvent* event); +bool QPdfView_override_virtual_focusOutEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_focusOutEvent(void* self, QFocusEvent* event); +bool QPdfView_override_virtual_enterEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_enterEvent(void* self, QEnterEvent* event); +bool QPdfView_override_virtual_leaveEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_leaveEvent(void* self, QEvent* event); +bool QPdfView_override_virtual_moveEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_moveEvent(void* self, QMoveEvent* event); +bool QPdfView_override_virtual_closeEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_closeEvent(void* self, QCloseEvent* event); +bool QPdfView_override_virtual_tabletEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_tabletEvent(void* self, QTabletEvent* event); +bool QPdfView_override_virtual_actionEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_actionEvent(void* self, QActionEvent* event); +bool QPdfView_override_virtual_showEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_showEvent(void* self, QShowEvent* event); +bool QPdfView_override_virtual_hideEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_hideEvent(void* self, QHideEvent* event); +bool QPdfView_override_virtual_nativeEvent(void* self, intptr_t slot); +bool QPdfView_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, intptr_t* result); +bool QPdfView_override_virtual_metric(void* self, intptr_t slot); +int QPdfView_virtualbase_metric(const void* self, int param1); +bool QPdfView_override_virtual_initPainter(void* self, intptr_t slot); +void QPdfView_virtualbase_initPainter(const void* self, QPainter* painter); +bool QPdfView_override_virtual_redirected(void* self, intptr_t slot); +QPaintDevice* QPdfView_virtualbase_redirected(const void* self, QPoint* offset); +bool QPdfView_override_virtual_sharedPainter(void* self, intptr_t slot); +QPainter* QPdfView_virtualbase_sharedPainter(const void* self); +bool QPdfView_override_virtual_inputMethodEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* param1); +bool QPdfView_override_virtual_inputMethodQuery(void* self, intptr_t slot); +QVariant* QPdfView_virtualbase_inputMethodQuery(const void* self, int param1); +bool QPdfView_override_virtual_focusNextPrevChild(void* self, intptr_t slot); +bool QPdfView_virtualbase_focusNextPrevChild(void* self, bool next); +bool QPdfView_override_virtual_timerEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QPdfView_override_virtual_childEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_childEvent(void* self, QChildEvent* event); +bool QPdfView_override_virtual_customEvent(void* self, intptr_t slot); +void QPdfView_virtualbase_customEvent(void* self, QEvent* event); +bool QPdfView_override_virtual_connectNotify(void* self, intptr_t slot); +void QPdfView_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QPdfView_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QPdfView_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); +void QPdfView_protectedbase_setViewportMargins(bool* _dynamic_cast_ok, void* self, int left, int top, int right, int bottom); +QMargins* QPdfView_protectedbase_viewportMargins(bool* _dynamic_cast_ok, const void* self); +void QPdfView_protectedbase_drawFrame(bool* _dynamic_cast_ok, void* self, QPainter* param1); +void QPdfView_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self); +void QPdfView_protectedbase_create(bool* _dynamic_cast_ok, void* self); +void QPdfView_protectedbase_destroy(bool* _dynamic_cast_ok, void* self); +bool QPdfView_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self); +bool QPdfView_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self); +QObject* QPdfView_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QPdfView_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QPdfView_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QPdfView_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +void QPdfView_delete(QPdfView* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif From c43c65ee2acb22ac8452faacbc1fe8fbf82d1154 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sun, 20 Apr 2025 13:12:13 -0400 Subject: [PATCH 3/6] .gitignore: Add Qt PDF Examples --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index dee88c0f..6e2e35e0 100644 --- a/.gitignore +++ b/.gitignore @@ -35,6 +35,7 @@ examples/modelview_color6/modelview_color6 examples/libraries/extras-scintillaedit/extras-scintillaedit examples/libraries/qt-multimedia/qt-multimedia examples/libraries/qt-network/qt-network +examples/libraries/qt-pdf/qt-pdf examples/libraries/qt-printsupport/qt-printsupport examples/libraries/qt-script/qt-script examples/libraries/qt-svg/qt-svg @@ -43,6 +44,7 @@ examples/libraries/qt-webkit/qt-webkit examples/libraries/qt6-multimedia/qt6-multimedia examples/libraries/qt6-network/qt6-network examples/libraries/qt6-network-sctp/qt6-network-sctp +examples/libraries/qt6-pdf/qt6-pdf examples/libraries/qt6-webengine/qt6-webengine examples/libraries/restricted-extras-charts6/restricted-extras-charts6 examples/libraries/restricted-extras-qscintilla/restricted-extras-qscintilla From fdb15300e8a8a8dc0da46c7d085910e86257e1ab Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sun, 20 Apr 2025 13:15:14 -0400 Subject: [PATCH 4/6] pdf: Add Qt PDF examples --- examples/libraries/qt-pdf/example.pdf | Bin 0 -> 204778 bytes examples/libraries/qt-pdf/main.go | 27 ++++++++++++++++++++++ examples/libraries/qt-pdf/screenshot.png | Bin 0 -> 29320 bytes examples/libraries/qt6-pdf/example.pdf | Bin 0 -> 204778 bytes examples/libraries/qt6-pdf/main.go | 27 ++++++++++++++++++++++ examples/libraries/qt6-pdf/screenshot.png | Bin 0 -> 25922 bytes 6 files changed, 54 insertions(+) create mode 100644 examples/libraries/qt-pdf/example.pdf create mode 100644 examples/libraries/qt-pdf/main.go create mode 100644 examples/libraries/qt-pdf/screenshot.png create mode 100644 examples/libraries/qt6-pdf/example.pdf create mode 100644 examples/libraries/qt6-pdf/main.go create mode 100644 examples/libraries/qt6-pdf/screenshot.png diff --git a/examples/libraries/qt-pdf/example.pdf b/examples/libraries/qt-pdf/example.pdf new file mode 100644 index 0000000000000000000000000000000000000000..47141f8856e56bb76283546f790d9756537ff8ea GIT binary patch literal 204778 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

uD} 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ⅇBCUhD8N6UwClTVX(!q%KP{C!w8*!`A*yy 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

uD} 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ⅇBCUhD8N6UwClTVX(!q%KP{C!w8*!`A*yy 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 E0CFIcD*ylh literal 0 HcmV?d00001 From 72ad16086a8522d9a74aa4335d004ec0e141ef2a Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sun, 20 Apr 2025 13:25:26 -0400 Subject: [PATCH 5/6] genbindings.Dockerfile: Add Qt PDF packages --- docker/genbindings.Dockerfile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docker/genbindings.Dockerfile b/docker/genbindings.Dockerfile index 6b2d8925..73f8850b 100644 --- a/docker/genbindings.Dockerfile +++ b/docker/genbindings.Dockerfile @@ -5,6 +5,7 @@ RUN DEBIAN_FRONTEND=noninteractive apt-get update && \ golang-go \ qtbase5-dev \ qtmultimedia5-dev \ + qtpdf5-dev \ qtscript5-dev \ libqt5svg5-dev \ libqt5webkit5-dev \ @@ -13,6 +14,7 @@ RUN DEBIAN_FRONTEND=noninteractive apt-get update && \ qt6-charts-dev \ qt6-declarative-dev \ qt6-multimedia-dev \ + qt6-pdf-dev \ qt6-svg-dev \ qt6-webengine-dev \ libqscintilla2-qt5-dev \ From 4e841e0053a796610492ca7120612de3188634fc Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sun, 20 Apr 2025 14:15:48 -0400 Subject: [PATCH 6/6] README: Add Qt PDF packages --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 3625e7f1..88d35c91 100644 --- a/README.md +++ b/README.md @@ -149,7 +149,7 @@ For dynamic linking, with the system Qt (Qt 5): apt install qtbase5-dev build-essential golang-go # Debian / Ubuntu (Full) -apt install qtbase5-dev libqscintilla2-qt5-dev libqt5svg5-dev libqt5webchannel5-dev libqt5webkit5-dev qtbase5-private-dev qtmultimedia5-dev qtwebengine5-dev qtwebengine5-private-dev build-essential golang-go +apt install qtbase5-dev libqscintilla2-qt5-dev libqt5svg5-dev libqt5webchannel5-dev libqt5webkit5-dev qtbase5-private-dev qtmultimedia5-dev qtpdf5-dev qtwebengine5-dev qtwebengine5-private-dev build-essential golang-go ``` For dynamic linking, with the system Qt (Qt 6): @@ -159,10 +159,10 @@ For dynamic linking, with the system Qt (Qt 6): apt install qt6-base-dev build-essential golang-go # Debian / Ubuntu (Full) -apt install qt6-base-dev libqscintilla2-qt6-dev qt6-base-private-dev qt6-charts-dev qt6-multimedia-dev qt6-svg-dev qt6-webchannel-dev qt6-webengine-dev qt6-declarative-dev qml6-module-qtquick-{controls,shapes,layouts,templates,window} build-essential golang-go +apt install qt6-base-dev libqscintilla2-qt6-dev qt6-base-private-dev qt6-charts-dev qt6-multimedia-dev qt6-pdf-dev qt6-svg-dev qt6-webchannel-dev qt6-webengine-dev qt6-declarative-dev qml6-module-qtquick-{controls,shapes,layouts,templates,window} build-essential golang-go # Fedora -dnf install qt6-qtbase-devel qscintilla-qt6-devel qt6-qtcharts-devel qt6-qtmultimedia-devel qt6-qtsvg-devel qt6-qtwebchannel-devel qt6-qtwebengine-devel qt6-qtdeclarative-devel golang +dnf install qt6-qtbase-devel qscintilla-qt6-devel qt6-qtcharts-devel qt6-qtmultimedia-devel qt6-qtpdf-devel qt6-qtsvg-devel qt6-qtwebchannel-devel qt6-qtwebengine-devel qt6-qtdeclarative-devel golang # Manjaro pamac install qt6-base qscintilla-qt6 qt6-charts qt6-multimedia qt6-svg qt6-webchannel qt6-webengine qt6-declarative go @@ -260,7 +260,7 @@ To add an icon and other properties to the .exe, you can use [the go-winres tool pkg install git pkg install devel/pkgconf pkg install go -pkg install qt6-base qt6-charts qt6-multimedia qt6-svg qt6-webchannel qt6-webengine qt6-declarative qscintilla2-qt6 +pkg install qt6-base qt6-charts qt6-multimedia qt6-pdf qt6-svg qt6-webchannel qt6-webengine qt6-declarative qscintilla2-qt6 go build -ldflags '-s -w' ```