From 7ad295e6b542f01eca87478f64c6a36e45aca74a Mon Sep 17 00:00:00 2001 From: Vladimir Kononov Date: Tue, 30 Dec 2025 18:34:23 +0300 Subject: [PATCH 01/12] Add Qt6 QCXML and QStateMachine --- cmd/genbindings/config-libraries.go | 37 +++++++++++++++++++++++++++++ docker/genbindings.Dockerfile | 3 ++- 2 files changed, 39 insertions(+), 1 deletion(-) diff --git a/cmd/genbindings/config-libraries.go b/cmd/genbindings/config-libraries.go index 8c6054de5..90f0005d8 100644 --- a/cmd/genbindings/config-libraries.go +++ b/cmd/genbindings/config-libraries.go @@ -1,6 +1,7 @@ package main import ( + "fmt" "path/filepath" "strings" ) @@ -603,6 +604,42 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) { ClangMatchSameHeaderDefinitionOnly, ) + // Qt 6 QStateMachine + // Depends on QtCore and QtQml + generate( + "qt6/statemachine", + []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtStateMachine", + "/usr/include/x86_64-linux-gnu/qt6/QtStateMachineQml", + }, + AllowAllHeaders, + clangBin, + fmt.Sprintf("--std=c++17 %s %s", + pkgConfigCflags("Qt6StateMachine"), + pkgConfigCflags("Qt6StateMachineQml"), + ), + outDir, + ClangMatchSameHeaderDefinitionOnly, + ) + + // Qt 6 SCXML + // Depends on QtCore and QtQml + generate( + "qt6/scxml", + []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtScxml", + "/usr/include/x86_64-linux-gnu/qt6/QtScxmlQml", + }, + AllowAllHeaders, + clangBin, + fmt.Sprintf("--std=c++17 %s %s", + pkgConfigCflags("Qt6Scxml"), + pkgConfigCflags("Qt6ScxmlQml"), + ), + outDir, + ClangMatchSameHeaderDefinitionOnly, + ) + // Qt 6 Charts // Depends on QtCore/Gui/Widgets generate( diff --git a/docker/genbindings.Dockerfile b/docker/genbindings.Dockerfile index 0b670a502..0aaa5cb89 100644 --- a/docker/genbindings.Dockerfile +++ b/docker/genbindings.Dockerfile @@ -18,8 +18,9 @@ RUN DEBIAN_FRONTEND=noninteractive apt-get update && \ qt6-multimedia-dev \ qt6-pdf-dev \ qt6-positioning-dev \ - qt6-tools-dev \ + qt6-scxml-dev \ qt6-svg-dev \ + qt6-tools-dev \ qt6-webengine-dev \ libqscintilla2-qt5-dev \ libqscintilla2-qt6-dev \ From 882758c244cf596fa6d9d1e3472b90646bc98d08 Mon Sep 17 00:00:00 2001 From: Vladimir Kononov Date: Sat, 10 Jan 2026 21:17:12 +0300 Subject: [PATCH 02/12] Add cflags.go for Qt6 statemachine and scxml modules --- qt6/scxml/cflags.go | 6 ++++++ qt6/statemachine/cflags.go | 6 ++++++ 2 files changed, 12 insertions(+) create mode 100644 qt6/scxml/cflags.go create mode 100644 qt6/statemachine/cflags.go diff --git a/qt6/scxml/cflags.go b/qt6/scxml/cflags.go new file mode 100644 index 000000000..47a41cb0b --- /dev/null +++ b/qt6/scxml/cflags.go @@ -0,0 +1,6 @@ +package statemachine + +/* +#cgo pkg-config: Qt6Scxml Qt6ScxmlQml +*/ +import "C" diff --git a/qt6/statemachine/cflags.go b/qt6/statemachine/cflags.go new file mode 100644 index 000000000..655e92255 --- /dev/null +++ b/qt6/statemachine/cflags.go @@ -0,0 +1,6 @@ +package statemachine + +/* +#cgo pkg-config: Qt6StateMachine Qt6StateMachineQml +*/ +import "C" From f5352e2ad4d149a39c300fc4798c4c6ea0f038fb Mon Sep 17 00:00:00 2001 From: Vladimir Kononov Date: Sat, 10 Jan 2026 23:39:20 +0300 Subject: [PATCH 03/12] Generate bindings for Qt6 QSCXML and QStateMachine --- qt6/scxml/gen_qscxmlcompiler.cpp | 167 ++ qt6/scxml/gen_qscxmlcompiler.go | 234 +++ qt6/scxml/gen_qscxmlcompiler.h | 58 + qt6/scxml/gen_qscxmlcppdatamodel.cpp | 857 ++++++++ qt6/scxml/gen_qscxmlcppdatamodel.go | 835 ++++++++ qt6/scxml/gen_qscxmlcppdatamodel.h | 116 ++ qt6/scxml/gen_qscxmldatamodel.cpp | 877 +++++++++ qt6/scxml/gen_qscxmldatamodel.go | 871 +++++++++ qt6/scxml/gen_qscxmldatamodel.h | 131 ++ qt6/scxml/gen_qscxmlerror.cpp | 82 + qt6/scxml/gen_qscxmlerror.go | 123 ++ qt6/scxml/gen_qscxmlerror.h | 40 + qt6/scxml/gen_qscxmlevent.cpp | 172 ++ qt6/scxml/gen_qscxmlevent.go | 216 ++ qt6/scxml/gen_qscxmlevent.h | 56 + qt6/scxml/gen_qscxmlexecutablecontent.cpp | 206 ++ qt6/scxml/gen_qscxmlexecutablecontent.go | 405 ++++ qt6/scxml/gen_qscxmlexecutablecontent.h | 108 + qt6/scxml/gen_qscxmlinvokableservice.cpp | 1732 +++++++++++++++++ qt6/scxml/gen_qscxmlinvokableservice.go | 1705 ++++++++++++++++ qt6/scxml/gen_qscxmlinvokableservice.h | 209 ++ qt6/scxml/gen_qscxmlnulldatamodel.cpp | 901 +++++++++ qt6/scxml/gen_qscxmlnulldatamodel.go | 872 +++++++++ qt6/scxml/gen_qscxmlnulldatamodel.h | 118 ++ qt6/scxml/gen_qscxmlstatemachine.cpp | 535 +++++ qt6/scxml/gen_qscxmlstatemachine.go | 656 +++++++ qt6/scxml/gen_qscxmlstatemachine.h | 124 ++ qt6/scxml/gen_qscxmltabledata.cpp | 85 + qt6/scxml/gen_qscxmltabledata.go | 116 ++ qt6/scxml/gen_qscxmltabledata.h | 61 + qt6/statemachine/gen_qabstractstate.cpp | 108 + qt6/statemachine/gen_qabstractstate.go | 166 ++ qt6/statemachine/gen_qabstractstate.h | 59 + qt6/statemachine/gen_qabstracttransition.cpp | 509 +++++ qt6/statemachine/gen_qabstracttransition.go | 517 +++++ qt6/statemachine/gen_qabstracttransition.h | 100 + qt6/statemachine/gen_qeventtransition.cpp | 456 +++++ qt6/statemachine/gen_qeventtransition.go | 447 +++++ qt6/statemachine/gen_qeventtransition.h | 87 + qt6/statemachine/gen_qfinalstate.cpp | 430 ++++ qt6/statemachine/gen_qfinalstate.go | 417 ++++ qt6/statemachine/gen_qfinalstate.h | 81 + qt6/statemachine/gen_qhistorystate.cpp | 487 +++++ qt6/statemachine/gen_qhistorystate.go | 501 +++++ qt6/statemachine/gen_qhistorystate.h | 95 + qt6/statemachine/gen_qkeyeventtransition.cpp | 457 +++++ qt6/statemachine/gen_qkeyeventtransition.go | 447 +++++ qt6/statemachine/gen_qkeyeventtransition.h | 88 + .../gen_qmouseeventtransition.cpp | 467 +++++ qt6/statemachine/gen_qmouseeventtransition.go | 457 +++++ qt6/statemachine/gen_qmouseeventtransition.h | 92 + qt6/statemachine/gen_qsignaltransition.cpp | 476 +++++ qt6/statemachine/gen_qsignaltransition.go | 488 +++++ qt6/statemachine/gen_qsignaltransition.h | 90 + qt6/statemachine/gen_qstate.cpp | 536 +++++ qt6/statemachine/gen_qstate.go | 570 ++++++ qt6/statemachine/gen_qstate.h | 105 + qt6/statemachine/gen_qstatemachine.cpp | 936 +++++++++ qt6/statemachine/gen_qstatemachine.go | 970 +++++++++ qt6/statemachine/gen_qstatemachine.h | 167 ++ 60 files changed, 23474 insertions(+) create mode 100644 qt6/scxml/gen_qscxmlcompiler.cpp create mode 100644 qt6/scxml/gen_qscxmlcompiler.go create mode 100644 qt6/scxml/gen_qscxmlcompiler.h create mode 100644 qt6/scxml/gen_qscxmlcppdatamodel.cpp create mode 100644 qt6/scxml/gen_qscxmlcppdatamodel.go create mode 100644 qt6/scxml/gen_qscxmlcppdatamodel.h create mode 100644 qt6/scxml/gen_qscxmldatamodel.cpp create mode 100644 qt6/scxml/gen_qscxmldatamodel.go create mode 100644 qt6/scxml/gen_qscxmldatamodel.h create mode 100644 qt6/scxml/gen_qscxmlerror.cpp create mode 100644 qt6/scxml/gen_qscxmlerror.go create mode 100644 qt6/scxml/gen_qscxmlerror.h create mode 100644 qt6/scxml/gen_qscxmlevent.cpp create mode 100644 qt6/scxml/gen_qscxmlevent.go create mode 100644 qt6/scxml/gen_qscxmlevent.h create mode 100644 qt6/scxml/gen_qscxmlexecutablecontent.cpp create mode 100644 qt6/scxml/gen_qscxmlexecutablecontent.go create mode 100644 qt6/scxml/gen_qscxmlexecutablecontent.h create mode 100644 qt6/scxml/gen_qscxmlinvokableservice.cpp create mode 100644 qt6/scxml/gen_qscxmlinvokableservice.go create mode 100644 qt6/scxml/gen_qscxmlinvokableservice.h create mode 100644 qt6/scxml/gen_qscxmlnulldatamodel.cpp create mode 100644 qt6/scxml/gen_qscxmlnulldatamodel.go create mode 100644 qt6/scxml/gen_qscxmlnulldatamodel.h create mode 100644 qt6/scxml/gen_qscxmlstatemachine.cpp create mode 100644 qt6/scxml/gen_qscxmlstatemachine.go create mode 100644 qt6/scxml/gen_qscxmlstatemachine.h create mode 100644 qt6/scxml/gen_qscxmltabledata.cpp create mode 100644 qt6/scxml/gen_qscxmltabledata.go create mode 100644 qt6/scxml/gen_qscxmltabledata.h create mode 100644 qt6/statemachine/gen_qabstractstate.cpp create mode 100644 qt6/statemachine/gen_qabstractstate.go create mode 100644 qt6/statemachine/gen_qabstractstate.h create mode 100644 qt6/statemachine/gen_qabstracttransition.cpp create mode 100644 qt6/statemachine/gen_qabstracttransition.go create mode 100644 qt6/statemachine/gen_qabstracttransition.h create mode 100644 qt6/statemachine/gen_qeventtransition.cpp create mode 100644 qt6/statemachine/gen_qeventtransition.go create mode 100644 qt6/statemachine/gen_qeventtransition.h create mode 100644 qt6/statemachine/gen_qfinalstate.cpp create mode 100644 qt6/statemachine/gen_qfinalstate.go create mode 100644 qt6/statemachine/gen_qfinalstate.h create mode 100644 qt6/statemachine/gen_qhistorystate.cpp create mode 100644 qt6/statemachine/gen_qhistorystate.go create mode 100644 qt6/statemachine/gen_qhistorystate.h create mode 100644 qt6/statemachine/gen_qkeyeventtransition.cpp create mode 100644 qt6/statemachine/gen_qkeyeventtransition.go create mode 100644 qt6/statemachine/gen_qkeyeventtransition.h create mode 100644 qt6/statemachine/gen_qmouseeventtransition.cpp create mode 100644 qt6/statemachine/gen_qmouseeventtransition.go create mode 100644 qt6/statemachine/gen_qmouseeventtransition.h create mode 100644 qt6/statemachine/gen_qsignaltransition.cpp create mode 100644 qt6/statemachine/gen_qsignaltransition.go create mode 100644 qt6/statemachine/gen_qsignaltransition.h create mode 100644 qt6/statemachine/gen_qstate.cpp create mode 100644 qt6/statemachine/gen_qstate.go create mode 100644 qt6/statemachine/gen_qstate.h create mode 100644 qt6/statemachine/gen_qstatemachine.cpp create mode 100644 qt6/statemachine/gen_qstatemachine.go create mode 100644 qt6/statemachine/gen_qstatemachine.h diff --git a/qt6/scxml/gen_qscxmlcompiler.cpp b/qt6/scxml/gen_qscxmlcompiler.cpp new file mode 100644 index 000000000..3fcbf99d8 --- /dev/null +++ b/qt6/scxml/gen_qscxmlcompiler.cpp @@ -0,0 +1,167 @@ +#include +#include +#include +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlCompiler__Loader +#include +#include +#include +#include +#include +#include +#include +#include "gen_qscxmlcompiler.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct miqt_string miqt_exec_callback_QScxmlCompiler__Loader_load(QScxmlCompiler__Loader*, intptr_t, struct miqt_string, struct miqt_string, struct miqt_array /* of struct miqt_string */ ); +#ifdef __cplusplus +} /* extern C */ +#endif + +QScxmlCompiler* QScxmlCompiler_new(QXmlStreamReader* xmlReader) { + return new (std::nothrow) QScxmlCompiler(xmlReader); +} + +struct miqt_string QScxmlCompiler_fileName(const QScxmlCompiler* self) { + QString _ret = self->fileName(); + // 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 QScxmlCompiler_setFileName(QScxmlCompiler* self, struct miqt_string fileName) { + QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); + self->setFileName(fileName_QString); +} + +QScxmlCompiler__Loader* QScxmlCompiler_loader(const QScxmlCompiler* self) { + return self->loader(); +} + +void QScxmlCompiler_setLoader(QScxmlCompiler* self, QScxmlCompiler__Loader* newLoader) { + self->setLoader(newLoader); +} + +QScxmlStateMachine* QScxmlCompiler_compile(QScxmlCompiler* self) { + return self->compile(); +} + +struct miqt_array /* of QScxmlError* */ QScxmlCompiler_errors(const QScxmlCompiler* self) { + QList _ret = self->errors(); + // Convert QList<> from C++ memory to manually-managed C memory + QScxmlError** _arr = static_cast(malloc(sizeof(QScxmlError*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QScxmlError(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +void QScxmlCompiler_delete(QScxmlCompiler* self) { + delete self; +} + +class MiqtVirtualQScxmlCompilerLoader final : public QScxmlCompiler::Loader { +public: + + MiqtVirtualQScxmlCompilerLoader(): QScxmlCompiler::Loader() {} + + virtual ~MiqtVirtualQScxmlCompilerLoader() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__load = 0; + + // Subclass to allow providing a Go implementation + virtual QByteArray load(const QString& name, const QString& baseDir, QStringList* errors) override { + if (handle__load == 0) { + return QByteArray(); // Pure virtual, there is no base we can call + } + + const QString name_ret = name; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray name_b = name_ret.toUtf8(); + struct miqt_string name_ms; + name_ms.len = name_b.length(); + name_ms.data = static_cast(malloc(name_ms.len)); + memcpy(name_ms.data, name_b.data(), name_ms.len); + struct miqt_string sigval1 = name_ms; + const QString baseDir_ret = baseDir; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray baseDir_b = baseDir_ret.toUtf8(); + struct miqt_string baseDir_ms; + baseDir_ms.len = baseDir_b.length(); + baseDir_ms.data = static_cast(malloc(baseDir_ms.len)); + memcpy(baseDir_ms.data, baseDir_b.data(), baseDir_ms.len); + struct miqt_string sigval2 = baseDir_ms; + QStringList* errors_ret = errors; + // Convert QList<> from C++ memory to manually-managed C memory + struct miqt_string* errors_arr = static_cast(malloc(sizeof(struct miqt_string) * errors_ret.length())); + for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { + QString errors_lv_ret = errors_ret[i]; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray errors_lv_b = errors_lv_ret.toUtf8(); + struct miqt_string errors_lv_ms; + errors_lv_ms.len = errors_lv_b.length(); + errors_lv_ms.data = static_cast(malloc(errors_lv_ms.len)); + memcpy(errors_lv_ms.data, errors_lv_b.data(), errors_lv_ms.len); + errors_arr[i] = errors_lv_ms; + } + struct miqt_array errors_out; + errors_out.len = errors_ret.length(); + errors_out.data = static_cast(errors_arr); + struct miqt_array /* of struct miqt_string */ sigval3 = errors_out; + struct miqt_string callback_return_value = miqt_exec_callback_QScxmlCompiler__Loader_load(this, handle__load, sigval1, sigval2, sigval3); + QByteArray callback_return_value_QByteArray(callback_return_value.data, callback_return_value.len); + return callback_return_value_QByteArray; + } + +}; + +QScxmlCompiler__Loader* QScxmlCompiler__Loader_new() { + return new (std::nothrow) MiqtVirtualQScxmlCompilerLoader(); +} + +struct miqt_string QScxmlCompiler__Loader_load(QScxmlCompiler__Loader* self, struct miqt_string name, struct miqt_string baseDir, struct miqt_array /* of struct miqt_string */ errors) { + QString name_QString = QString::fromUtf8(name.data, name.len); + QString baseDir_QString = QString::fromUtf8(baseDir.data, baseDir.len); + QStringList errors_QList; + errors_QList.reserve(errors.len); + struct miqt_string* errors_arr = static_cast(errors.data); + for(size_t i = 0; i < errors.len; ++i) { + QString errors_arr_i_QString = QString::fromUtf8(errors_arr[i].data, errors_arr[i].len); + errors_QList.push_back(errors_arr_i_QString); + } + QByteArray _qb = self->load(name_QString, baseDir_QString, &errors_QList); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void QScxmlCompiler__Loader_operatorAssign(QScxmlCompiler__Loader* self, QScxmlCompiler__Loader* param1) { + self->operator=(*param1); +} + +bool QScxmlCompiler__Loader_override_virtual_load(void* self, intptr_t slot) { + MiqtVirtualQScxmlCompilerLoader* self_cast = dynamic_cast( (QScxmlCompiler::Loader*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__load = slot; + return true; +} + +void QScxmlCompiler__Loader_delete(QScxmlCompiler__Loader* self) { + delete self; +} + diff --git a/qt6/scxml/gen_qscxmlcompiler.go b/qt6/scxml/gen_qscxmlcompiler.go new file mode 100644 index 000000000..cc31e27d8 --- /dev/null +++ b/qt6/scxml/gen_qscxmlcompiler.go @@ -0,0 +1,234 @@ +package scxml + +/* + +#include "gen_qscxmlcompiler.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QScxmlCompiler struct { + h *C.QScxmlCompiler +} + +func (this *QScxmlCompiler) cPointer() *C.QScxmlCompiler { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlCompiler) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlCompiler constructs the type using only CGO pointers. +func newQScxmlCompiler(h *C.QScxmlCompiler) *QScxmlCompiler { + if h == nil { + return nil + } + + return &QScxmlCompiler{h: h} +} + +// UnsafeNewQScxmlCompiler constructs the type using only unsafe pointers. +func UnsafeNewQScxmlCompiler(h unsafe.Pointer) *QScxmlCompiler { + return newQScxmlCompiler((*C.QScxmlCompiler)(h)) +} + +// NewQScxmlCompiler constructs a new QScxmlCompiler object. +func NewQScxmlCompiler(xmlReader *qt6.QXmlStreamReader) *QScxmlCompiler { + + return newQScxmlCompiler(C.QScxmlCompiler_new((*C.QXmlStreamReader)(xmlReader.UnsafePointer()))) +} + +func (this *QScxmlCompiler) FileName() string { + var _ms C.struct_miqt_string = C.QScxmlCompiler_fileName(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlCompiler) SetFileName(fileName string) { + 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)) + C.QScxmlCompiler_setFileName(this.h, fileName_ms) +} + +func (this *QScxmlCompiler) Loader() *QScxmlCompiler__Loader { + return newQScxmlCompiler__Loader(C.QScxmlCompiler_loader(this.h)) +} + +func (this *QScxmlCompiler) SetLoader(newLoader *QScxmlCompiler__Loader) { + C.QScxmlCompiler_setLoader(this.h, newLoader.cPointer()) +} + +func (this *QScxmlCompiler) Compile() *QScxmlStateMachine { + return newQScxmlStateMachine(C.QScxmlCompiler_compile(this.h)) +} + +func (this *QScxmlCompiler) Errors() []QScxmlError { + var _ma C.struct_miqt_array = C.QScxmlCompiler_errors(this.h) + _ret := make([]QScxmlError, int(_ma.len)) + _outCast := (*[0xffff]*C.QScxmlError)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := newQScxmlError(_outCast[i]) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret +} + +// Delete this object from C++ memory. +func (this *QScxmlCompiler) Delete() { + C.QScxmlCompiler_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 *QScxmlCompiler) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlCompiler) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type QScxmlCompiler__Loader struct { + h *C.QScxmlCompiler__Loader +} + +func (this *QScxmlCompiler__Loader) cPointer() *C.QScxmlCompiler__Loader { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlCompiler__Loader) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlCompiler__Loader constructs the type using only CGO pointers. +func newQScxmlCompiler__Loader(h *C.QScxmlCompiler__Loader) *QScxmlCompiler__Loader { + if h == nil { + return nil + } + + return &QScxmlCompiler__Loader{h: h} +} + +// UnsafeNewQScxmlCompiler__Loader constructs the type using only unsafe pointers. +func UnsafeNewQScxmlCompiler__Loader(h unsafe.Pointer) *QScxmlCompiler__Loader { + return newQScxmlCompiler__Loader((*C.QScxmlCompiler__Loader)(h)) +} + +// NewQScxmlCompiler__Loader constructs a new QScxmlCompiler::Loader object. +func NewQScxmlCompiler__Loader() *QScxmlCompiler__Loader { + + return newQScxmlCompiler__Loader(C.QScxmlCompiler__Loader_new()) +} + +func (this *QScxmlCompiler__Loader) Load(name string, baseDir string, errors []string) []byte { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + baseDir_ms := C.struct_miqt_string{} + baseDir_ms.data = C.CString(baseDir) + baseDir_ms.len = C.size_t(len(baseDir)) + defer C.free(unsafe.Pointer(baseDir_ms.data)) + errors_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(errors)))) + defer C.free(unsafe.Pointer(errors_CArray)) + for i := range errors { + errors_i_ms := C.struct_miqt_string{} + errors_i_ms.data = C.CString(errors[i]) + errors_i_ms.len = C.size_t(len(errors[i])) + defer C.free(unsafe.Pointer(errors_i_ms.data)) + errors_CArray[i] = errors_i_ms + } + errors_ma := C.struct_miqt_array{len: C.size_t(len(errors)), data: unsafe.Pointer(errors_CArray)} + var _bytearray C.struct_miqt_string = C.QScxmlCompiler__Loader_load(this.h, name_ms, baseDir_ms, errors_ma) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *QScxmlCompiler__Loader) OperatorAssign(param1 *QScxmlCompiler__Loader) { + C.QScxmlCompiler__Loader_operatorAssign(this.h, param1.cPointer()) +} +func (this *QScxmlCompiler__Loader) OnLoad(slot func(name string, baseDir string, errors []string) []byte) { + ok := C.QScxmlCompiler__Loader_override_virtual_load(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCompiler__Loader_load +func miqt_exec_callback_QScxmlCompiler__Loader_load(self *C.QScxmlCompiler__Loader, cb C.intptr_t, name C.struct_miqt_string, baseDir C.struct_miqt_string, errors C.struct_miqt_array) C.struct_miqt_string { + gofunc, ok := cgo.Handle(cb).Value().(func(name string, baseDir string, errors []string) []byte) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var name_ms C.struct_miqt_string = name + name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) + C.free(unsafe.Pointer(name_ms.data)) + slotval1 := name_ret + var baseDir_ms C.struct_miqt_string = baseDir + baseDir_ret := C.GoStringN(baseDir_ms.data, C.int(int64(baseDir_ms.len))) + C.free(unsafe.Pointer(baseDir_ms.data)) + slotval2 := baseDir_ret + var errors_ma C.struct_miqt_array = errors + errors_ret := make([]string, int(errors_ma.len)) + errors_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(errors_ma.data)) // hey ya + for i := 0; i < int(errors_ma.len); i++ { + var errors_lv_ms C.struct_miqt_string = errors_outCast[i] + errors_lv_ret := C.GoStringN(errors_lv_ms.data, C.int(int64(errors_lv_ms.len))) + C.free(unsafe.Pointer(errors_lv_ms.data)) + errors_ret[i] = errors_lv_ret + } + slotval3 := errors_ret + + virtualReturn := gofunc(slotval1, slotval2, slotval3) + virtualReturn_alias := C.struct_miqt_string{} + if len(virtualReturn) > 0 { + virtualReturn_alias.data = (*C.char)(unsafe.Pointer(&virtualReturn[0])) + } else { + virtualReturn_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + virtualReturn_alias.len = C.size_t(len(virtualReturn)) + + return virtualReturn_alias + +} + +// Delete this object from C++ memory. +func (this *QScxmlCompiler__Loader) Delete() { + C.QScxmlCompiler__Loader_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 *QScxmlCompiler__Loader) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlCompiler__Loader) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/scxml/gen_qscxmlcompiler.h b/qt6/scxml/gen_qscxmlcompiler.h new file mode 100644 index 000000000..3a77b63a5 --- /dev/null +++ b/qt6/scxml/gen_qscxmlcompiler.h @@ -0,0 +1,58 @@ +#pragma once +#ifndef MIQT_QT6_SCXML_GEN_QSCXMLCOMPILER_H +#define MIQT_QT6_SCXML_GEN_QSCXMLCOMPILER_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QScxmlCompiler; +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlCompiler__Loader) +typedef QScxmlCompiler::Loader QScxmlCompiler__Loader; +#else +class QScxmlCompiler__Loader; +#endif +class QScxmlError; +class QScxmlStateMachine; +class QXmlStreamReader; +#else +typedef struct QScxmlCompiler QScxmlCompiler; +typedef struct QScxmlCompiler__Loader QScxmlCompiler__Loader; +typedef struct QScxmlError QScxmlError; +typedef struct QScxmlStateMachine QScxmlStateMachine; +typedef struct QXmlStreamReader QXmlStreamReader; +#endif + +QScxmlCompiler* QScxmlCompiler_new(QXmlStreamReader* xmlReader); +struct miqt_string QScxmlCompiler_fileName(const QScxmlCompiler* self); +void QScxmlCompiler_setFileName(QScxmlCompiler* self, struct miqt_string fileName); +QScxmlCompiler__Loader* QScxmlCompiler_loader(const QScxmlCompiler* self); +void QScxmlCompiler_setLoader(QScxmlCompiler* self, QScxmlCompiler__Loader* newLoader); +QScxmlStateMachine* QScxmlCompiler_compile(QScxmlCompiler* self); +struct miqt_array /* of QScxmlError* */ QScxmlCompiler_errors(const QScxmlCompiler* self); + +void QScxmlCompiler_delete(QScxmlCompiler* self); + +QScxmlCompiler__Loader* QScxmlCompiler__Loader_new(); +struct miqt_string QScxmlCompiler__Loader_load(QScxmlCompiler__Loader* self, struct miqt_string name, struct miqt_string baseDir, struct miqt_array /* of struct miqt_string */ errors); +void QScxmlCompiler__Loader_operatorAssign(QScxmlCompiler__Loader* self, QScxmlCompiler__Loader* param1); + +bool QScxmlCompiler__Loader_override_virtual_load(void* self, intptr_t slot); +struct miqt_string QScxmlCompiler__Loader_virtualbase_load(void* self, struct miqt_string name, struct miqt_string baseDir, struct miqt_array /* of struct miqt_string */ errors); + +void QScxmlCompiler__Loader_delete(QScxmlCompiler__Loader* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/scxml/gen_qscxmlcppdatamodel.cpp b/qt6/scxml/gen_qscxmlcppdatamodel.cpp new file mode 100644 index 000000000..0dade1dbf --- /dev/null +++ b/qt6/scxml/gen_qscxmlcppdatamodel.cpp @@ -0,0 +1,857 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlDataModel__ForeachLoopBody +#include +#include +#include +#include +#include +#include +#include +#include "gen_qscxmlcppdatamodel.h" + +#ifdef __cplusplus +extern "C" { +#endif + +bool miqt_exec_callback_QScxmlCppDataModel_setup(QScxmlCppDataModel*, intptr_t, struct miqt_map /* of struct miqt_string to QVariant* */ ); +void miqt_exec_callback_QScxmlCppDataModel_evaluateAssignment(QScxmlCppDataModel*, intptr_t, int, bool*); +void miqt_exec_callback_QScxmlCppDataModel_evaluateInitialization(QScxmlCppDataModel*, intptr_t, int, bool*); +void miqt_exec_callback_QScxmlCppDataModel_evaluateForeach(QScxmlCppDataModel*, intptr_t, int, bool*, QScxmlDataModel__ForeachLoopBody*); +void miqt_exec_callback_QScxmlCppDataModel_setScxmlEvent(QScxmlCppDataModel*, intptr_t, QScxmlEvent*); +QVariant* miqt_exec_callback_QScxmlCppDataModel_scxmlProperty(const QScxmlCppDataModel*, intptr_t, struct miqt_string); +bool miqt_exec_callback_QScxmlCppDataModel_hasScxmlProperty(const QScxmlCppDataModel*, intptr_t, struct miqt_string); +bool miqt_exec_callback_QScxmlCppDataModel_setScxmlProperty(QScxmlCppDataModel*, intptr_t, struct miqt_string, QVariant*, struct miqt_string); +struct miqt_string miqt_exec_callback_QScxmlCppDataModel_evaluateToString(QScxmlCppDataModel*, intptr_t, int, bool*); +bool miqt_exec_callback_QScxmlCppDataModel_evaluateToBool(QScxmlCppDataModel*, intptr_t, int, bool*); +QVariant* miqt_exec_callback_QScxmlCppDataModel_evaluateToVariant(QScxmlCppDataModel*, intptr_t, int, bool*); +void miqt_exec_callback_QScxmlCppDataModel_evaluateToVoid(QScxmlCppDataModel*, intptr_t, int, bool*); +bool miqt_exec_callback_QScxmlCppDataModel_event(QScxmlCppDataModel*, intptr_t, QEvent*); +bool miqt_exec_callback_QScxmlCppDataModel_eventFilter(QScxmlCppDataModel*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QScxmlCppDataModel_timerEvent(QScxmlCppDataModel*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QScxmlCppDataModel_childEvent(QScxmlCppDataModel*, intptr_t, QChildEvent*); +void miqt_exec_callback_QScxmlCppDataModel_customEvent(QScxmlCppDataModel*, intptr_t, QEvent*); +void miqt_exec_callback_QScxmlCppDataModel_connectNotify(QScxmlCppDataModel*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QScxmlCppDataModel_disconnectNotify(QScxmlCppDataModel*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQScxmlCppDataModel final : public QScxmlCppDataModel { +public: + + MiqtVirtualQScxmlCppDataModel(): QScxmlCppDataModel() {} + MiqtVirtualQScxmlCppDataModel(QObject* parent): QScxmlCppDataModel(parent) {} + + virtual ~MiqtVirtualQScxmlCppDataModel() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__setup = 0; + + // Subclass to allow providing a Go implementation + virtual bool setup(const QVariantMap& initialDataValues) override { + if (handle__setup == 0) { + return QScxmlCppDataModel::setup(initialDataValues); + } + + const QVariantMap& initialDataValues_ret = initialDataValues; + // Convert QMap<> from C++ memory to manually-managed C memory + struct miqt_string* initialDataValues_karr = static_cast(malloc(sizeof(struct miqt_string) * initialDataValues_ret.size())); + QVariant** initialDataValues_varr = static_cast(malloc(sizeof(QVariant*) * initialDataValues_ret.size())); + int initialDataValues_ctr = 0; + for (auto initialDataValues_itr = initialDataValues_ret.keyValueBegin(); initialDataValues_itr != initialDataValues_ret.keyValueEnd(); ++initialDataValues_itr) { + QString initialDataValues_mapkey_ret = initialDataValues_itr->first; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray initialDataValues_mapkey_b = initialDataValues_mapkey_ret.toUtf8(); + struct miqt_string initialDataValues_mapkey_ms; + initialDataValues_mapkey_ms.len = initialDataValues_mapkey_b.length(); + initialDataValues_mapkey_ms.data = static_cast(malloc(initialDataValues_mapkey_ms.len)); + memcpy(initialDataValues_mapkey_ms.data, initialDataValues_mapkey_b.data(), initialDataValues_mapkey_ms.len); + initialDataValues_karr[initialDataValues_ctr] = initialDataValues_mapkey_ms; + initialDataValues_varr[initialDataValues_ctr] = new QVariant(initialDataValues_itr->second); + initialDataValues_ctr++; + } + struct miqt_map initialDataValues_out; + initialDataValues_out.len = initialDataValues_ret.size(); + initialDataValues_out.keys = static_cast(initialDataValues_karr); + initialDataValues_out.values = static_cast(initialDataValues_varr); + struct miqt_map /* of struct miqt_string to QVariant* */ sigval1 = initialDataValues_out; + bool callback_return_value = miqt_exec_callback_QScxmlCppDataModel_setup(this, handle__setup, sigval1); + return callback_return_value; + } + + friend bool QScxmlCppDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateAssignment = 0; + + // Subclass to allow providing a Go implementation + virtual void evaluateAssignment(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateAssignment == 0) { + QScxmlCppDataModel::evaluateAssignment(id, ok); + return; + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + miqt_exec_callback_QScxmlCppDataModel_evaluateAssignment(this, handle__evaluateAssignment, sigval1, sigval2); + + } + + friend void QScxmlCppDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok); + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateInitialization = 0; + + // Subclass to allow providing a Go implementation + virtual void evaluateInitialization(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateInitialization == 0) { + QScxmlCppDataModel::evaluateInitialization(id, ok); + return; + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + miqt_exec_callback_QScxmlCppDataModel_evaluateInitialization(this, handle__evaluateInitialization, sigval1, sigval2); + + } + + friend void QScxmlCppDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok); + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateForeach = 0; + + // Subclass to allow providing a Go implementation + virtual void evaluateForeach(QScxmlExecutableContent::EvaluatorId id, bool* ok, QScxmlDataModel::ForeachLoopBody* body) override { + if (handle__evaluateForeach == 0) { + QScxmlCppDataModel::evaluateForeach(id, ok, body); + return; + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + QScxmlDataModel__ForeachLoopBody* sigval3 = body; + miqt_exec_callback_QScxmlCppDataModel_evaluateForeach(this, handle__evaluateForeach, sigval1, sigval2, sigval3); + + } + + friend void QScxmlCppDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setScxmlEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void setScxmlEvent(const QScxmlEvent& scxmlEvent) override { + if (handle__setScxmlEvent == 0) { + QScxmlCppDataModel::setScxmlEvent(scxmlEvent); + return; + } + + const QScxmlEvent& scxmlEvent_ret = scxmlEvent; + // Cast returned reference into pointer + QScxmlEvent* sigval1 = const_cast(&scxmlEvent_ret); + miqt_exec_callback_QScxmlCppDataModel_setScxmlEvent(this, handle__setScxmlEvent, sigval1); + + } + + friend void QScxmlCppDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* scxmlEvent); + + // cgo.Handle value for overwritten implementation + intptr_t handle__scxmlProperty = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant scxmlProperty(const QString& name) const override { + if (handle__scxmlProperty == 0) { + return QScxmlCppDataModel::scxmlProperty(name); + } + + const QString name_ret = name; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray name_b = name_ret.toUtf8(); + struct miqt_string name_ms; + name_ms.len = name_b.length(); + name_ms.data = static_cast(malloc(name_ms.len)); + memcpy(name_ms.data, name_b.data(), name_ms.len); + struct miqt_string sigval1 = name_ms; + QVariant* callback_return_value = miqt_exec_callback_QScxmlCppDataModel_scxmlProperty(this, handle__scxmlProperty, sigval1); + return *callback_return_value; + } + + friend QVariant* QScxmlCppDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name); + + // cgo.Handle value for overwritten implementation + intptr_t handle__hasScxmlProperty = 0; + + // Subclass to allow providing a Go implementation + virtual bool hasScxmlProperty(const QString& name) const override { + if (handle__hasScxmlProperty == 0) { + return QScxmlCppDataModel::hasScxmlProperty(name); + } + + const QString name_ret = name; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray name_b = name_ret.toUtf8(); + struct miqt_string name_ms; + name_ms.len = name_b.length(); + name_ms.data = static_cast(malloc(name_ms.len)); + memcpy(name_ms.data, name_b.data(), name_ms.len); + struct miqt_string sigval1 = name_ms; + bool callback_return_value = miqt_exec_callback_QScxmlCppDataModel_hasScxmlProperty(this, handle__hasScxmlProperty, sigval1); + return callback_return_value; + } + + friend bool QScxmlCppDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setScxmlProperty = 0; + + // Subclass to allow providing a Go implementation + virtual bool setScxmlProperty(const QString& name, const QVariant& value, const QString& context) override { + if (handle__setScxmlProperty == 0) { + return QScxmlCppDataModel::setScxmlProperty(name, value, context); + } + + const QString name_ret = name; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray name_b = name_ret.toUtf8(); + struct miqt_string name_ms; + name_ms.len = name_b.length(); + name_ms.data = static_cast(malloc(name_ms.len)); + memcpy(name_ms.data, name_b.data(), name_ms.len); + struct miqt_string sigval1 = name_ms; + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval2 = const_cast(&value_ret); + const QString context_ret = context; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray context_b = context_ret.toUtf8(); + struct miqt_string context_ms; + context_ms.len = context_b.length(); + context_ms.data = static_cast(malloc(context_ms.len)); + memcpy(context_ms.data, context_b.data(), context_ms.len); + struct miqt_string sigval3 = context_ms; + bool callback_return_value = miqt_exec_callback_QScxmlCppDataModel_setScxmlProperty(this, handle__setScxmlProperty, sigval1, sigval2, sigval3); + return callback_return_value; + } + + friend bool QScxmlCppDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context); + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateToString = 0; + + // Subclass to allow providing a Go implementation + virtual QString evaluateToString(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateToString == 0) { + return QString(); // Pure virtual, there is no base we can call + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + struct miqt_string callback_return_value = miqt_exec_callback_QScxmlCppDataModel_evaluateToString(this, handle__evaluateToString, sigval1, sigval2); + QString callback_return_value_QString = QString::fromUtf8(callback_return_value.data, callback_return_value.len); + return callback_return_value_QString; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateToBool = 0; + + // Subclass to allow providing a Go implementation + virtual bool evaluateToBool(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateToBool == 0) { + return false; // Pure virtual, there is no base we can call + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + bool callback_return_value = miqt_exec_callback_QScxmlCppDataModel_evaluateToBool(this, handle__evaluateToBool, sigval1, sigval2); + return callback_return_value; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateToVariant = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant evaluateToVariant(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateToVariant == 0) { + return QVariant(); // Pure virtual, there is no base we can call + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + QVariant* callback_return_value = miqt_exec_callback_QScxmlCppDataModel_evaluateToVariant(this, handle__evaluateToVariant, sigval1, sigval2); + return *callback_return_value; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateToVoid = 0; + + // Subclass to allow providing a Go implementation + virtual void evaluateToVoid(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateToVoid == 0) { + return; // Pure virtual, there is no base we can call + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + miqt_exec_callback_QScxmlCppDataModel_evaluateToVoid(this, handle__evaluateToVoid, sigval1, sigval2); + + } + + // 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 QScxmlCppDataModel::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QScxmlCppDataModel_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QScxmlCppDataModel_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 QScxmlCppDataModel::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QScxmlCppDataModel_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QScxmlCppDataModel_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) { + QScxmlCppDataModel::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QScxmlCppDataModel_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QScxmlCppDataModel_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) { + QScxmlCppDataModel::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QScxmlCppDataModel_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QScxmlCppDataModel_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) { + QScxmlCppDataModel::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QScxmlCppDataModel_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QScxmlCppDataModel_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) { + QScxmlCppDataModel::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlCppDataModel_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QScxmlCppDataModel_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) { + QScxmlCppDataModel::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlCppDataModel_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QScxmlCppDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QScxmlCppDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlCppDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlCppDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QScxmlCppDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QScxmlCppDataModel* QScxmlCppDataModel_new() { + return new (std::nothrow) MiqtVirtualQScxmlCppDataModel(); +} + +QScxmlCppDataModel* QScxmlCppDataModel_new2(QObject* parent) { + return new (std::nothrow) MiqtVirtualQScxmlCppDataModel(parent); +} + +void QScxmlCppDataModel_virtbase(QScxmlCppDataModel* src, QScxmlDataModel** outptr_QScxmlDataModel) { + *outptr_QScxmlDataModel = static_cast(src); +} + +QMetaObject* QScxmlCppDataModel_metaObject(const QScxmlCppDataModel* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QScxmlCppDataModel_metacast(QScxmlCppDataModel* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QScxmlCppDataModel_tr(const char* s) { + QString _ret = QScxmlCppDataModel::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; +} + +bool QScxmlCppDataModel_setup(QScxmlCppDataModel* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues) { + QVariantMap initialDataValues_QMap; + struct miqt_string* initialDataValues_karr = static_cast(initialDataValues.keys); + QVariant** initialDataValues_varr = static_cast(initialDataValues.values); + for(size_t i = 0; i < initialDataValues.len; ++i) { + QString initialDataValues_karr_i_QString = QString::fromUtf8(initialDataValues_karr[i].data, initialDataValues_karr[i].len); + initialDataValues_QMap[initialDataValues_karr_i_QString] = *(initialDataValues_varr[i]); + } + return self->setup(initialDataValues_QMap); +} + +void QScxmlCppDataModel_evaluateAssignment(QScxmlCppDataModel* self, int id, bool* ok) { + self->evaluateAssignment(static_cast(id), ok); +} + +void QScxmlCppDataModel_evaluateInitialization(QScxmlCppDataModel* self, int id, bool* ok) { + self->evaluateInitialization(static_cast(id), ok); +} + +void QScxmlCppDataModel_evaluateForeach(QScxmlCppDataModel* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body) { + self->evaluateForeach(static_cast(id), ok, body); +} + +void QScxmlCppDataModel_setScxmlEvent(QScxmlCppDataModel* self, QScxmlEvent* scxmlEvent) { + self->setScxmlEvent(*scxmlEvent); +} + +QScxmlEvent* QScxmlCppDataModel_scxmlEvent(const QScxmlCppDataModel* self) { + const QScxmlEvent& _ret = self->scxmlEvent(); + // Cast returned reference into pointer + return const_cast(&_ret); +} + +QVariant* QScxmlCppDataModel_scxmlProperty(const QScxmlCppDataModel* self, struct miqt_string name) { + QString name_QString = QString::fromUtf8(name.data, name.len); + return new QVariant(self->scxmlProperty(name_QString)); +} + +bool QScxmlCppDataModel_hasScxmlProperty(const QScxmlCppDataModel* self, struct miqt_string name) { + QString name_QString = QString::fromUtf8(name.data, name.len); + return self->hasScxmlProperty(name_QString); +} + +bool QScxmlCppDataModel_setScxmlProperty(QScxmlCppDataModel* self, struct miqt_string name, QVariant* value, struct miqt_string context) { + QString name_QString = QString::fromUtf8(name.data, name.len); + QString context_QString = QString::fromUtf8(context.data, context.len); + return self->setScxmlProperty(name_QString, *value, context_QString); +} + +bool QScxmlCppDataModel_inState(const QScxmlCppDataModel* self, struct miqt_string stateName) { + QString stateName_QString = QString::fromUtf8(stateName.data, stateName.len); + return self->inState(stateName_QString); +} + +struct miqt_string QScxmlCppDataModel_tr2(const char* s, const char* c) { + QString _ret = QScxmlCppDataModel::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 QScxmlCppDataModel_tr3(const char* s, const char* c, int n) { + QString _ret = QScxmlCppDataModel::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 QScxmlCppDataModel_override_virtual_setup(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setup = slot; + return true; +} + +bool QScxmlCppDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues) { + QVariantMap initialDataValues_QMap; + struct miqt_string* initialDataValues_karr = static_cast(initialDataValues.keys); + QVariant** initialDataValues_varr = static_cast(initialDataValues.values); + for(size_t i = 0; i < initialDataValues.len; ++i) { + QString initialDataValues_karr_i_QString = QString::fromUtf8(initialDataValues_karr[i].data, initialDataValues_karr[i].len); + initialDataValues_QMap[initialDataValues_karr_i_QString] = *(initialDataValues_varr[i]); + } + return static_cast(self)->QScxmlCppDataModel::setup(initialDataValues_QMap); +} + +bool QScxmlCppDataModel_override_virtual_evaluateAssignment(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateAssignment = slot; + return true; +} + +void QScxmlCppDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok) { + static_cast(self)->QScxmlCppDataModel::evaluateAssignment(static_cast(id), ok); +} + +bool QScxmlCppDataModel_override_virtual_evaluateInitialization(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateInitialization = slot; + return true; +} + +void QScxmlCppDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok) { + static_cast(self)->QScxmlCppDataModel::evaluateInitialization(static_cast(id), ok); +} + +bool QScxmlCppDataModel_override_virtual_evaluateForeach(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateForeach = slot; + return true; +} + +void QScxmlCppDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body) { + static_cast(self)->QScxmlCppDataModel::evaluateForeach(static_cast(id), ok, body); +} + +bool QScxmlCppDataModel_override_virtual_setScxmlEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setScxmlEvent = slot; + return true; +} + +void QScxmlCppDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* scxmlEvent) { + static_cast(self)->QScxmlCppDataModel::setScxmlEvent(*scxmlEvent); +} + +bool QScxmlCppDataModel_override_virtual_scxmlProperty(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__scxmlProperty = slot; + return true; +} + +QVariant* QScxmlCppDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name) { + QString name_QString = QString::fromUtf8(name.data, name.len); + return new QVariant(static_cast(self)->QScxmlCppDataModel::scxmlProperty(name_QString)); +} + +bool QScxmlCppDataModel_override_virtual_hasScxmlProperty(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__hasScxmlProperty = slot; + return true; +} + +bool QScxmlCppDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name) { + QString name_QString = QString::fromUtf8(name.data, name.len); + return static_cast(self)->QScxmlCppDataModel::hasScxmlProperty(name_QString); +} + +bool QScxmlCppDataModel_override_virtual_setScxmlProperty(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setScxmlProperty = slot; + return true; +} + +bool QScxmlCppDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context) { + QString name_QString = QString::fromUtf8(name.data, name.len); + QString context_QString = QString::fromUtf8(context.data, context.len); + return static_cast(self)->QScxmlCppDataModel::setScxmlProperty(name_QString, *value, context_QString); +} + +bool QScxmlCppDataModel_override_virtual_evaluateToString(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateToString = slot; + return true; +} + +bool QScxmlCppDataModel_override_virtual_evaluateToBool(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateToBool = slot; + return true; +} + +bool QScxmlCppDataModel_override_virtual_evaluateToVariant(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateToVariant = slot; + return true; +} + +bool QScxmlCppDataModel_override_virtual_evaluateToVoid(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateToVoid = slot; + return true; +} + +bool QScxmlCppDataModel_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QScxmlCppDataModel_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QScxmlCppDataModel::event(event); +} + +bool QScxmlCppDataModel_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QScxmlCppDataModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QScxmlCppDataModel::eventFilter(watched, event); +} + +bool QScxmlCppDataModel_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QScxmlCppDataModel_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QScxmlCppDataModel::timerEvent(event); +} + +bool QScxmlCppDataModel_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QScxmlCppDataModel_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QScxmlCppDataModel::childEvent(event); +} + +bool QScxmlCppDataModel_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QScxmlCppDataModel_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QScxmlCppDataModel::customEvent(event); +} + +bool QScxmlCppDataModel_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QScxmlCppDataModel_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlCppDataModel::connectNotify(*signal); +} + +bool QScxmlCppDataModel_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QScxmlCppDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlCppDataModel::disconnectNotify(*signal); +} + +QObject* QScxmlCppDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QScxmlCppDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QScxmlCppDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QScxmlCppDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QScxmlCppDataModel_delete(QScxmlCppDataModel* self) { + delete self; +} + diff --git a/qt6/scxml/gen_qscxmlcppdatamodel.go b/qt6/scxml/gen_qscxmlcppdatamodel.go new file mode 100644 index 000000000..a7fda149e --- /dev/null +++ b/qt6/scxml/gen_qscxmlcppdatamodel.go @@ -0,0 +1,835 @@ +package scxml + +/* + +#include "gen_qscxmlcppdatamodel.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QScxmlCppDataModel struct { + h *C.QScxmlCppDataModel + *QScxmlDataModel +} + +func (this *QScxmlCppDataModel) cPointer() *C.QScxmlCppDataModel { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlCppDataModel) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlCppDataModel constructs the type using only CGO pointers. +func newQScxmlCppDataModel(h *C.QScxmlCppDataModel) *QScxmlCppDataModel { + if h == nil { + return nil + } + var outptr_QScxmlDataModel *C.QScxmlDataModel = nil + C.QScxmlCppDataModel_virtbase(h, &outptr_QScxmlDataModel) + + return &QScxmlCppDataModel{h: h, + QScxmlDataModel: newQScxmlDataModel(outptr_QScxmlDataModel)} +} + +// UnsafeNewQScxmlCppDataModel constructs the type using only unsafe pointers. +func UnsafeNewQScxmlCppDataModel(h unsafe.Pointer) *QScxmlCppDataModel { + return newQScxmlCppDataModel((*C.QScxmlCppDataModel)(h)) +} + +// NewQScxmlCppDataModel constructs a new QScxmlCppDataModel object. +func NewQScxmlCppDataModel() *QScxmlCppDataModel { + + return newQScxmlCppDataModel(C.QScxmlCppDataModel_new()) +} + +// NewQScxmlCppDataModel2 constructs a new QScxmlCppDataModel object. +func NewQScxmlCppDataModel2(parent *qt6.QObject) *QScxmlCppDataModel { + + return newQScxmlCppDataModel(C.QScxmlCppDataModel_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QScxmlCppDataModel) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlCppDataModel_metaObject(this.h))) +} + +func (this *QScxmlCppDataModel) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QScxmlCppDataModel_metacast(this.h, param1_Cstring)) +} + +func QScxmlCppDataModel_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QScxmlCppDataModel_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlCppDataModel) Setup(initialDataValues map[string]qt6.QVariant) bool { + initialDataValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialDataValues)))) + defer C.free(unsafe.Pointer(initialDataValues_Keys_CArray)) + initialDataValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialDataValues)))) + defer C.free(unsafe.Pointer(initialDataValues_Values_CArray)) + initialDataValues_ctr := 0 + for initialDataValues_k, initialDataValues_v := range initialDataValues { + initialDataValues_k_ms := C.struct_miqt_string{} + initialDataValues_k_ms.data = C.CString(initialDataValues_k) + initialDataValues_k_ms.len = C.size_t(len(initialDataValues_k)) + defer C.free(unsafe.Pointer(initialDataValues_k_ms.data)) + initialDataValues_Keys_CArray[initialDataValues_ctr] = initialDataValues_k_ms + initialDataValues_Values_CArray[initialDataValues_ctr] = (*C.QVariant)(initialDataValues_v.UnsafePointer()) + initialDataValues_ctr++ + } + initialDataValues_mm := C.struct_miqt_map{ + len: C.size_t(len(initialDataValues)), + keys: unsafe.Pointer(initialDataValues_Keys_CArray), + values: unsafe.Pointer(initialDataValues_Values_CArray), + } + return (bool)(C.QScxmlCppDataModel_setup(this.h, initialDataValues_mm)) +} + +func (this *QScxmlCppDataModel) EvaluateAssignment(id int, ok *bool) { + C.QScxmlCppDataModel_evaluateAssignment(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) +} + +func (this *QScxmlCppDataModel) EvaluateInitialization(id int, ok *bool) { + C.QScxmlCppDataModel_evaluateInitialization(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) +} + +func (this *QScxmlCppDataModel) EvaluateForeach(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody) { + C.QScxmlCppDataModel_evaluateForeach(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok)), body.cPointer()) +} + +func (this *QScxmlCppDataModel) SetScxmlEvent(scxmlEvent *QScxmlEvent) { + C.QScxmlCppDataModel_setScxmlEvent(this.h, scxmlEvent.cPointer()) +} + +func (this *QScxmlCppDataModel) ScxmlEvent() *QScxmlEvent { + return newQScxmlEvent(C.QScxmlCppDataModel_scxmlEvent(this.h)) +} + +func (this *QScxmlCppDataModel) ScxmlProperty(name string) *qt6.QVariant { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlCppDataModel_scxmlProperty(this.h, name_ms))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QScxmlCppDataModel) HasScxmlProperty(name string) bool { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + return (bool)(C.QScxmlCppDataModel_hasScxmlProperty(this.h, name_ms)) +} + +func (this *QScxmlCppDataModel) SetScxmlProperty(name string, value *qt6.QVariant, context string) bool { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + context_ms := C.struct_miqt_string{} + context_ms.data = C.CString(context) + context_ms.len = C.size_t(len(context)) + defer C.free(unsafe.Pointer(context_ms.data)) + return (bool)(C.QScxmlCppDataModel_setScxmlProperty(this.h, name_ms, (*C.QVariant)(value.UnsafePointer()), context_ms)) +} + +func (this *QScxmlCppDataModel) InState(stateName string) bool { + stateName_ms := C.struct_miqt_string{} + stateName_ms.data = C.CString(stateName) + stateName_ms.len = C.size_t(len(stateName)) + defer C.free(unsafe.Pointer(stateName_ms.data)) + return (bool)(C.QScxmlCppDataModel_inState(this.h, stateName_ms)) +} + +func QScxmlCppDataModel_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.QScxmlCppDataModel_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QScxmlCppDataModel_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.QScxmlCppDataModel_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 +} + +// Sender can only be called from a QScxmlCppDataModel that was directly constructed. +func (this *QScxmlCppDataModel) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlCppDataModel_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 QScxmlCppDataModel that was directly constructed. +func (this *QScxmlCppDataModel) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QScxmlCppDataModel_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 QScxmlCppDataModel that was directly constructed. +func (this *QScxmlCppDataModel) 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.QScxmlCppDataModel_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 QScxmlCppDataModel that was directly constructed. +func (this *QScxmlCppDataModel) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QScxmlCppDataModel_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 *QScxmlCppDataModel) callVirtualBase_Setup(initialDataValues map[string]qt6.QVariant) bool { + initialDataValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialDataValues)))) + defer C.free(unsafe.Pointer(initialDataValues_Keys_CArray)) + initialDataValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialDataValues)))) + defer C.free(unsafe.Pointer(initialDataValues_Values_CArray)) + initialDataValues_ctr := 0 + for initialDataValues_k, initialDataValues_v := range initialDataValues { + initialDataValues_k_ms := C.struct_miqt_string{} + initialDataValues_k_ms.data = C.CString(initialDataValues_k) + initialDataValues_k_ms.len = C.size_t(len(initialDataValues_k)) + defer C.free(unsafe.Pointer(initialDataValues_k_ms.data)) + initialDataValues_Keys_CArray[initialDataValues_ctr] = initialDataValues_k_ms + initialDataValues_Values_CArray[initialDataValues_ctr] = (*C.QVariant)(initialDataValues_v.UnsafePointer()) + initialDataValues_ctr++ + } + initialDataValues_mm := C.struct_miqt_map{ + len: C.size_t(len(initialDataValues)), + keys: unsafe.Pointer(initialDataValues_Keys_CArray), + values: unsafe.Pointer(initialDataValues_Values_CArray), + } + + return (bool)(C.QScxmlCppDataModel_virtualbase_setup(unsafe.Pointer(this.h), initialDataValues_mm)) + +} +func (this *QScxmlCppDataModel) OnSetup(slot func(super func(initialDataValues map[string]qt6.QVariant) bool, initialDataValues map[string]qt6.QVariant) bool) { + ok := C.QScxmlCppDataModel_override_virtual_setup(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCppDataModel_setup +func miqt_exec_callback_QScxmlCppDataModel_setup(self *C.QScxmlCppDataModel, cb C.intptr_t, initialDataValues C.struct_miqt_map) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(initialDataValues map[string]qt6.QVariant) bool, initialDataValues map[string]qt6.QVariant) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var initialDataValues_mm C.struct_miqt_map = initialDataValues + initialDataValues_ret := make(map[string]qt6.QVariant, int(initialDataValues_mm.len)) + initialDataValues_Keys := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(initialDataValues_mm.keys)) + initialDataValues_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(initialDataValues_mm.values)) + for i := 0; i < int(initialDataValues_mm.len); i++ { + var initialDataValues_mapkey_ms C.struct_miqt_string = initialDataValues_Keys[i] + initialDataValues_mapkey_ret := C.GoStringN(initialDataValues_mapkey_ms.data, C.int(int64(initialDataValues_mapkey_ms.len))) + C.free(unsafe.Pointer(initialDataValues_mapkey_ms.data)) + initialDataValues_entry_Key := initialDataValues_mapkey_ret + initialDataValues_mapval_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(initialDataValues_Values[i])) + initialDataValues_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + initialDataValues_entry_Value := *initialDataValues_mapval_goptr + + initialDataValues_ret[initialDataValues_entry_Key] = initialDataValues_entry_Value + } + slotval1 := initialDataValues_ret + + virtualReturn := gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_Setup, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_EvaluateAssignment(id int, ok *bool) { + + C.QScxmlCppDataModel_virtualbase_evaluateAssignment(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) + +} +func (this *QScxmlCppDataModel) OnEvaluateAssignment(slot func(super func(id int, ok *bool), id int, ok *bool)) { + ok := C.QScxmlCppDataModel_override_virtual_evaluateAssignment(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCppDataModel_evaluateAssignment +func miqt_exec_callback_QScxmlCppDataModel_evaluateAssignment(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool), id int, ok *bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_EvaluateAssignment, slotval1, slotval2) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_EvaluateInitialization(id int, ok *bool) { + + C.QScxmlCppDataModel_virtualbase_evaluateInitialization(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) + +} +func (this *QScxmlCppDataModel) OnEvaluateInitialization(slot func(super func(id int, ok *bool), id int, ok *bool)) { + ok := C.QScxmlCppDataModel_override_virtual_evaluateInitialization(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCppDataModel_evaluateInitialization +func miqt_exec_callback_QScxmlCppDataModel_evaluateInitialization(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool), id int, ok *bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_EvaluateInitialization, slotval1, slotval2) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_EvaluateForeach(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody) { + + C.QScxmlCppDataModel_virtualbase_evaluateForeach(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok)), body.cPointer()) + +} +func (this *QScxmlCppDataModel) OnEvaluateForeach(slot func(super func(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody), id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody)) { + ok := C.QScxmlCppDataModel_override_virtual_evaluateForeach(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCppDataModel_evaluateForeach +func miqt_exec_callback_QScxmlCppDataModel_evaluateForeach(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool, body *C.QScxmlDataModel__ForeachLoopBody) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody), id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + slotval3 := newQScxmlDataModel__ForeachLoopBody(body) + + gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_EvaluateForeach, slotval1, slotval2, slotval3) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_SetScxmlEvent(scxmlEvent *QScxmlEvent) { + + C.QScxmlCppDataModel_virtualbase_setScxmlEvent(unsafe.Pointer(this.h), scxmlEvent.cPointer()) + +} +func (this *QScxmlCppDataModel) OnSetScxmlEvent(slot func(super func(scxmlEvent *QScxmlEvent), scxmlEvent *QScxmlEvent)) { + ok := C.QScxmlCppDataModel_override_virtual_setScxmlEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCppDataModel_setScxmlEvent +func miqt_exec_callback_QScxmlCppDataModel_setScxmlEvent(self *C.QScxmlCppDataModel, cb C.intptr_t, scxmlEvent *C.QScxmlEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(scxmlEvent *QScxmlEvent), scxmlEvent *QScxmlEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQScxmlEvent(scxmlEvent) + + gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_SetScxmlEvent, slotval1) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_ScxmlProperty(name string) *qt6.QVariant { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlCppDataModel_virtualbase_scxmlProperty(unsafe.Pointer(this.h), name_ms))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QScxmlCppDataModel) OnScxmlProperty(slot func(super func(name string) *qt6.QVariant, name string) *qt6.QVariant) { + ok := C.QScxmlCppDataModel_override_virtual_scxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCppDataModel_scxmlProperty +func miqt_exec_callback_QScxmlCppDataModel_scxmlProperty(self *C.QScxmlCppDataModel, cb C.intptr_t, name C.struct_miqt_string) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(name string) *qt6.QVariant, name string) *qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var name_ms C.struct_miqt_string = name + name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) + C.free(unsafe.Pointer(name_ms.data)) + slotval1 := name_ret + + virtualReturn := gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_ScxmlProperty, slotval1) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_HasScxmlProperty(name string) bool { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + + return (bool)(C.QScxmlCppDataModel_virtualbase_hasScxmlProperty(unsafe.Pointer(this.h), name_ms)) + +} +func (this *QScxmlCppDataModel) OnHasScxmlProperty(slot func(super func(name string) bool, name string) bool) { + ok := C.QScxmlCppDataModel_override_virtual_hasScxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCppDataModel_hasScxmlProperty +func miqt_exec_callback_QScxmlCppDataModel_hasScxmlProperty(self *C.QScxmlCppDataModel, cb C.intptr_t, name C.struct_miqt_string) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(name string) bool, name string) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var name_ms C.struct_miqt_string = name + name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) + C.free(unsafe.Pointer(name_ms.data)) + slotval1 := name_ret + + virtualReturn := gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_HasScxmlProperty, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_SetScxmlProperty(name string, value *qt6.QVariant, context string) bool { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + context_ms := C.struct_miqt_string{} + context_ms.data = C.CString(context) + context_ms.len = C.size_t(len(context)) + defer C.free(unsafe.Pointer(context_ms.data)) + + return (bool)(C.QScxmlCppDataModel_virtualbase_setScxmlProperty(unsafe.Pointer(this.h), name_ms, (*C.QVariant)(value.UnsafePointer()), context_ms)) + +} +func (this *QScxmlCppDataModel) OnSetScxmlProperty(slot func(super func(name string, value *qt6.QVariant, context string) bool, name string, value *qt6.QVariant, context string) bool) { + ok := C.QScxmlCppDataModel_override_virtual_setScxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCppDataModel_setScxmlProperty +func miqt_exec_callback_QScxmlCppDataModel_setScxmlProperty(self *C.QScxmlCppDataModel, cb C.intptr_t, name C.struct_miqt_string, value *C.QVariant, context C.struct_miqt_string) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(name string, value *qt6.QVariant, context string) bool, name string, value *qt6.QVariant, context string) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var name_ms C.struct_miqt_string = name + name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) + C.free(unsafe.Pointer(name_ms.data)) + slotval1 := name_ret + slotval2 := qt6.UnsafeNewQVariant(unsafe.Pointer(value)) + + var context_ms C.struct_miqt_string = context + context_ret := C.GoStringN(context_ms.data, C.int(int64(context_ms.len))) + C.free(unsafe.Pointer(context_ms.data)) + slotval3 := context_ret + + virtualReturn := gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_SetScxmlProperty, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} +func (this *QScxmlCppDataModel) OnEvaluateToString(slot func(id int, ok *bool) string) { + ok := C.QScxmlCppDataModel_override_virtual_evaluateToString(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCppDataModel_evaluateToString +func miqt_exec_callback_QScxmlCppDataModel_evaluateToString(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool) C.struct_miqt_string { + gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool) string) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + virtualReturn := gofunc(slotval1, slotval2) + virtualReturn_ms := C.struct_miqt_string{} + virtualReturn_ms.data = C.CString(virtualReturn) + virtualReturn_ms.len = C.size_t(len(virtualReturn)) + defer C.free(unsafe.Pointer(virtualReturn_ms.data)) + + return virtualReturn_ms + +} +func (this *QScxmlCppDataModel) OnEvaluateToBool(slot func(id int, ok *bool) bool) { + ok := C.QScxmlCppDataModel_override_virtual_evaluateToBool(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCppDataModel_evaluateToBool +func miqt_exec_callback_QScxmlCppDataModel_evaluateToBool(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + virtualReturn := gofunc(slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} +func (this *QScxmlCppDataModel) OnEvaluateToVariant(slot func(id int, ok *bool) *qt6.QVariant) { + ok := C.QScxmlCppDataModel_override_virtual_evaluateToVariant(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCppDataModel_evaluateToVariant +func miqt_exec_callback_QScxmlCppDataModel_evaluateToVariant(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool) *qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + virtualReturn := gofunc(slotval1, slotval2) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} +func (this *QScxmlCppDataModel) OnEvaluateToVoid(slot func(id int, ok *bool)) { + ok := C.QScxmlCppDataModel_override_virtual_evaluateToVoid(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlCppDataModel_evaluateToVoid +func miqt_exec_callback_QScxmlCppDataModel_evaluateToVoid(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + gofunc(slotval1, slotval2) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QScxmlCppDataModel_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlCppDataModel) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_event +func miqt_exec_callback_QScxmlCppDataModel_event(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QScxmlCppDataModel_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlCppDataModel) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_eventFilter +func miqt_exec_callback_QScxmlCppDataModel_eventFilter(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QScxmlCppDataModel_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QScxmlCppDataModel) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_timerEvent +func miqt_exec_callback_QScxmlCppDataModel_timerEvent(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QScxmlCppDataModel_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QScxmlCppDataModel) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_childEvent +func miqt_exec_callback_QScxmlCppDataModel_childEvent(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QScxmlCppDataModel_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QScxmlCppDataModel) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_customEvent +func miqt_exec_callback_QScxmlCppDataModel_customEvent(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlCppDataModel_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlCppDataModel) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_connectNotify +func miqt_exec_callback_QScxmlCppDataModel_connectNotify(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QScxmlCppDataModel) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlCppDataModel_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlCppDataModel) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_disconnectNotify +func miqt_exec_callback_QScxmlCppDataModel_disconnectNotify(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QScxmlCppDataModel) Delete() { + C.QScxmlCppDataModel_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 *QScxmlCppDataModel) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlCppDataModel) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/scxml/gen_qscxmlcppdatamodel.h b/qt6/scxml/gen_qscxmlcppdatamodel.h new file mode 100644 index 000000000..0538e2a4a --- /dev/null +++ b/qt6/scxml/gen_qscxmlcppdatamodel.h @@ -0,0 +1,116 @@ +#pragma once +#ifndef MIQT_QT6_SCXML_GEN_QSCXMLCPPDATAMODEL_H +#define MIQT_QT6_SCXML_GEN_QSCXMLCPPDATAMODEL_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 QScxmlCppDataModel; +class QScxmlDataModel; +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlDataModel__ForeachLoopBody) +typedef QScxmlDataModel::ForeachLoopBody QScxmlDataModel__ForeachLoopBody; +#else +class QScxmlDataModel__ForeachLoopBody; +#endif +class QScxmlEvent; +class QTimerEvent; +class QVariant; +#else +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QScxmlCppDataModel QScxmlCppDataModel; +typedef struct QScxmlDataModel QScxmlDataModel; +typedef struct QScxmlDataModel__ForeachLoopBody QScxmlDataModel__ForeachLoopBody; +typedef struct QScxmlEvent QScxmlEvent; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +#endif + +QScxmlCppDataModel* QScxmlCppDataModel_new(); +QScxmlCppDataModel* QScxmlCppDataModel_new2(QObject* parent); +void QScxmlCppDataModel_virtbase(QScxmlCppDataModel* src, QScxmlDataModel** outptr_QScxmlDataModel); +QMetaObject* QScxmlCppDataModel_metaObject(const QScxmlCppDataModel* self); +void* QScxmlCppDataModel_metacast(QScxmlCppDataModel* self, const char* param1); +struct miqt_string QScxmlCppDataModel_tr(const char* s); +bool QScxmlCppDataModel_setup(QScxmlCppDataModel* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); +void QScxmlCppDataModel_evaluateAssignment(QScxmlCppDataModel* self, int id, bool* ok); +void QScxmlCppDataModel_evaluateInitialization(QScxmlCppDataModel* self, int id, bool* ok); +void QScxmlCppDataModel_evaluateForeach(QScxmlCppDataModel* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); +void QScxmlCppDataModel_setScxmlEvent(QScxmlCppDataModel* self, QScxmlEvent* scxmlEvent); +QScxmlEvent* QScxmlCppDataModel_scxmlEvent(const QScxmlCppDataModel* self); +QVariant* QScxmlCppDataModel_scxmlProperty(const QScxmlCppDataModel* self, struct miqt_string name); +bool QScxmlCppDataModel_hasScxmlProperty(const QScxmlCppDataModel* self, struct miqt_string name); +bool QScxmlCppDataModel_setScxmlProperty(QScxmlCppDataModel* self, struct miqt_string name, QVariant* value, struct miqt_string context); +bool QScxmlCppDataModel_inState(const QScxmlCppDataModel* self, struct miqt_string stateName); +struct miqt_string QScxmlCppDataModel_tr2(const char* s, const char* c); +struct miqt_string QScxmlCppDataModel_tr3(const char* s, const char* c, int n); + +bool QScxmlCppDataModel_override_virtual_setup(void* self, intptr_t slot); +bool QScxmlCppDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); +bool QScxmlCppDataModel_override_virtual_evaluateAssignment(void* self, intptr_t slot); +void QScxmlCppDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok); +bool QScxmlCppDataModel_override_virtual_evaluateInitialization(void* self, intptr_t slot); +void QScxmlCppDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok); +bool QScxmlCppDataModel_override_virtual_evaluateForeach(void* self, intptr_t slot); +void QScxmlCppDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); +bool QScxmlCppDataModel_override_virtual_setScxmlEvent(void* self, intptr_t slot); +void QScxmlCppDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* scxmlEvent); +bool QScxmlCppDataModel_override_virtual_scxmlProperty(void* self, intptr_t slot); +QVariant* QScxmlCppDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name); +bool QScxmlCppDataModel_override_virtual_hasScxmlProperty(void* self, intptr_t slot); +bool QScxmlCppDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name); +bool QScxmlCppDataModel_override_virtual_setScxmlProperty(void* self, intptr_t slot); +bool QScxmlCppDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context); +bool QScxmlCppDataModel_override_virtual_evaluateToString(void* self, intptr_t slot); +struct miqt_string QScxmlCppDataModel_virtualbase_evaluateToString(void* self, int id, bool* ok); +bool QScxmlCppDataModel_override_virtual_evaluateToBool(void* self, intptr_t slot); +bool QScxmlCppDataModel_virtualbase_evaluateToBool(void* self, int id, bool* ok); +bool QScxmlCppDataModel_override_virtual_evaluateToVariant(void* self, intptr_t slot); +QVariant* QScxmlCppDataModel_virtualbase_evaluateToVariant(void* self, int id, bool* ok); +bool QScxmlCppDataModel_override_virtual_evaluateToVoid(void* self, intptr_t slot); +void QScxmlCppDataModel_virtualbase_evaluateToVoid(void* self, int id, bool* ok); +bool QScxmlCppDataModel_override_virtual_event(void* self, intptr_t slot); +bool QScxmlCppDataModel_virtualbase_event(void* self, QEvent* event); +bool QScxmlCppDataModel_override_virtual_eventFilter(void* self, intptr_t slot); +bool QScxmlCppDataModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QScxmlCppDataModel_override_virtual_timerEvent(void* self, intptr_t slot); +void QScxmlCppDataModel_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QScxmlCppDataModel_override_virtual_childEvent(void* self, intptr_t slot); +void QScxmlCppDataModel_virtualbase_childEvent(void* self, QChildEvent* event); +bool QScxmlCppDataModel_override_virtual_customEvent(void* self, intptr_t slot); +void QScxmlCppDataModel_virtualbase_customEvent(void* self, QEvent* event); +bool QScxmlCppDataModel_override_virtual_connectNotify(void* self, intptr_t slot); +void QScxmlCppDataModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QScxmlCppDataModel_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QScxmlCppDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QScxmlCppDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QScxmlCppDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QScxmlCppDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QScxmlCppDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QScxmlCppDataModel_delete(QScxmlCppDataModel* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/scxml/gen_qscxmldatamodel.cpp b/qt6/scxml/gen_qscxmldatamodel.cpp new file mode 100644 index 000000000..a13c6bc9a --- /dev/null +++ b/qt6/scxml/gen_qscxmldatamodel.cpp @@ -0,0 +1,877 @@ +#include +#include +#include +#include +#include +#include +#include +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlDataModel__ForeachLoopBody +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qscxmldatamodel.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QScxmlDataModel_stateMachineChanged(intptr_t, QScxmlStateMachine*); +bool miqt_exec_callback_QScxmlDataModel_setup(QScxmlDataModel*, intptr_t, struct miqt_map /* of struct miqt_string to QVariant* */ ); +struct miqt_string miqt_exec_callback_QScxmlDataModel_evaluateToString(QScxmlDataModel*, intptr_t, int, bool*); +bool miqt_exec_callback_QScxmlDataModel_evaluateToBool(QScxmlDataModel*, intptr_t, int, bool*); +QVariant* miqt_exec_callback_QScxmlDataModel_evaluateToVariant(QScxmlDataModel*, intptr_t, int, bool*); +void miqt_exec_callback_QScxmlDataModel_evaluateToVoid(QScxmlDataModel*, intptr_t, int, bool*); +void miqt_exec_callback_QScxmlDataModel_evaluateAssignment(QScxmlDataModel*, intptr_t, int, bool*); +void miqt_exec_callback_QScxmlDataModel_evaluateInitialization(QScxmlDataModel*, intptr_t, int, bool*); +void miqt_exec_callback_QScxmlDataModel_evaluateForeach(QScxmlDataModel*, intptr_t, int, bool*, QScxmlDataModel__ForeachLoopBody*); +void miqt_exec_callback_QScxmlDataModel_setScxmlEvent(QScxmlDataModel*, intptr_t, QScxmlEvent*); +QVariant* miqt_exec_callback_QScxmlDataModel_scxmlProperty(const QScxmlDataModel*, intptr_t, struct miqt_string); +bool miqt_exec_callback_QScxmlDataModel_hasScxmlProperty(const QScxmlDataModel*, intptr_t, struct miqt_string); +bool miqt_exec_callback_QScxmlDataModel_setScxmlProperty(QScxmlDataModel*, intptr_t, struct miqt_string, QVariant*, struct miqt_string); +bool miqt_exec_callback_QScxmlDataModel_event(QScxmlDataModel*, intptr_t, QEvent*); +bool miqt_exec_callback_QScxmlDataModel_eventFilter(QScxmlDataModel*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QScxmlDataModel_timerEvent(QScxmlDataModel*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QScxmlDataModel_childEvent(QScxmlDataModel*, intptr_t, QChildEvent*); +void miqt_exec_callback_QScxmlDataModel_customEvent(QScxmlDataModel*, intptr_t, QEvent*); +void miqt_exec_callback_QScxmlDataModel_connectNotify(QScxmlDataModel*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QScxmlDataModel_disconnectNotify(QScxmlDataModel*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QScxmlDataModel__ForeachLoopBody_run(QScxmlDataModel__ForeachLoopBody*, intptr_t, bool*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQScxmlDataModel final : public QScxmlDataModel { +public: + + MiqtVirtualQScxmlDataModel(): QScxmlDataModel() {} + MiqtVirtualQScxmlDataModel(QObject* parent): QScxmlDataModel(parent) {} + + virtual ~MiqtVirtualQScxmlDataModel() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__setup = 0; + + // Subclass to allow providing a Go implementation + virtual bool setup(const QVariantMap& initialDataValues) override { + if (handle__setup == 0) { + return false; // Pure virtual, there is no base we can call + } + + const QVariantMap& initialDataValues_ret = initialDataValues; + // Convert QMap<> from C++ memory to manually-managed C memory + struct miqt_string* initialDataValues_karr = static_cast(malloc(sizeof(struct miqt_string) * initialDataValues_ret.size())); + QVariant** initialDataValues_varr = static_cast(malloc(sizeof(QVariant*) * initialDataValues_ret.size())); + int initialDataValues_ctr = 0; + for (auto initialDataValues_itr = initialDataValues_ret.keyValueBegin(); initialDataValues_itr != initialDataValues_ret.keyValueEnd(); ++initialDataValues_itr) { + QString initialDataValues_mapkey_ret = initialDataValues_itr->first; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray initialDataValues_mapkey_b = initialDataValues_mapkey_ret.toUtf8(); + struct miqt_string initialDataValues_mapkey_ms; + initialDataValues_mapkey_ms.len = initialDataValues_mapkey_b.length(); + initialDataValues_mapkey_ms.data = static_cast(malloc(initialDataValues_mapkey_ms.len)); + memcpy(initialDataValues_mapkey_ms.data, initialDataValues_mapkey_b.data(), initialDataValues_mapkey_ms.len); + initialDataValues_karr[initialDataValues_ctr] = initialDataValues_mapkey_ms; + initialDataValues_varr[initialDataValues_ctr] = new QVariant(initialDataValues_itr->second); + initialDataValues_ctr++; + } + struct miqt_map initialDataValues_out; + initialDataValues_out.len = initialDataValues_ret.size(); + initialDataValues_out.keys = static_cast(initialDataValues_karr); + initialDataValues_out.values = static_cast(initialDataValues_varr); + struct miqt_map /* of struct miqt_string to QVariant* */ sigval1 = initialDataValues_out; + bool callback_return_value = miqt_exec_callback_QScxmlDataModel_setup(this, handle__setup, sigval1); + return callback_return_value; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateToString = 0; + + // Subclass to allow providing a Go implementation + virtual QString evaluateToString(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateToString == 0) { + return QString(); // Pure virtual, there is no base we can call + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + struct miqt_string callback_return_value = miqt_exec_callback_QScxmlDataModel_evaluateToString(this, handle__evaluateToString, sigval1, sigval2); + QString callback_return_value_QString = QString::fromUtf8(callback_return_value.data, callback_return_value.len); + return callback_return_value_QString; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateToBool = 0; + + // Subclass to allow providing a Go implementation + virtual bool evaluateToBool(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateToBool == 0) { + return false; // Pure virtual, there is no base we can call + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + bool callback_return_value = miqt_exec_callback_QScxmlDataModel_evaluateToBool(this, handle__evaluateToBool, sigval1, sigval2); + return callback_return_value; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateToVariant = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant evaluateToVariant(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateToVariant == 0) { + return QVariant(); // Pure virtual, there is no base we can call + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + QVariant* callback_return_value = miqt_exec_callback_QScxmlDataModel_evaluateToVariant(this, handle__evaluateToVariant, sigval1, sigval2); + return *callback_return_value; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateToVoid = 0; + + // Subclass to allow providing a Go implementation + virtual void evaluateToVoid(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateToVoid == 0) { + return; // Pure virtual, there is no base we can call + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + miqt_exec_callback_QScxmlDataModel_evaluateToVoid(this, handle__evaluateToVoid, sigval1, sigval2); + + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateAssignment = 0; + + // Subclass to allow providing a Go implementation + virtual void evaluateAssignment(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateAssignment == 0) { + return; // Pure virtual, there is no base we can call + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + miqt_exec_callback_QScxmlDataModel_evaluateAssignment(this, handle__evaluateAssignment, sigval1, sigval2); + + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateInitialization = 0; + + // Subclass to allow providing a Go implementation + virtual void evaluateInitialization(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateInitialization == 0) { + return; // Pure virtual, there is no base we can call + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + miqt_exec_callback_QScxmlDataModel_evaluateInitialization(this, handle__evaluateInitialization, sigval1, sigval2); + + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateForeach = 0; + + // Subclass to allow providing a Go implementation + virtual void evaluateForeach(QScxmlExecutableContent::EvaluatorId id, bool* ok, QScxmlDataModel::ForeachLoopBody* body) override { + if (handle__evaluateForeach == 0) { + return; // Pure virtual, there is no base we can call + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + QScxmlDataModel__ForeachLoopBody* sigval3 = body; + miqt_exec_callback_QScxmlDataModel_evaluateForeach(this, handle__evaluateForeach, sigval1, sigval2, sigval3); + + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__setScxmlEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void setScxmlEvent(const QScxmlEvent& event) override { + if (handle__setScxmlEvent == 0) { + return; // Pure virtual, there is no base we can call + } + + const QScxmlEvent& event_ret = event; + // Cast returned reference into pointer + QScxmlEvent* sigval1 = const_cast(&event_ret); + miqt_exec_callback_QScxmlDataModel_setScxmlEvent(this, handle__setScxmlEvent, sigval1); + + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__scxmlProperty = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant scxmlProperty(const QString& name) const override { + if (handle__scxmlProperty == 0) { + return QVariant(); // Pure virtual, there is no base we can call + } + + const QString name_ret = name; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray name_b = name_ret.toUtf8(); + struct miqt_string name_ms; + name_ms.len = name_b.length(); + name_ms.data = static_cast(malloc(name_ms.len)); + memcpy(name_ms.data, name_b.data(), name_ms.len); + struct miqt_string sigval1 = name_ms; + QVariant* callback_return_value = miqt_exec_callback_QScxmlDataModel_scxmlProperty(this, handle__scxmlProperty, sigval1); + return *callback_return_value; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__hasScxmlProperty = 0; + + // Subclass to allow providing a Go implementation + virtual bool hasScxmlProperty(const QString& name) const override { + if (handle__hasScxmlProperty == 0) { + return false; // Pure virtual, there is no base we can call + } + + const QString name_ret = name; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray name_b = name_ret.toUtf8(); + struct miqt_string name_ms; + name_ms.len = name_b.length(); + name_ms.data = static_cast(malloc(name_ms.len)); + memcpy(name_ms.data, name_b.data(), name_ms.len); + struct miqt_string sigval1 = name_ms; + bool callback_return_value = miqt_exec_callback_QScxmlDataModel_hasScxmlProperty(this, handle__hasScxmlProperty, sigval1); + return callback_return_value; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__setScxmlProperty = 0; + + // Subclass to allow providing a Go implementation + virtual bool setScxmlProperty(const QString& name, const QVariant& value, const QString& context) override { + if (handle__setScxmlProperty == 0) { + return false; // Pure virtual, there is no base we can call + } + + const QString name_ret = name; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray name_b = name_ret.toUtf8(); + struct miqt_string name_ms; + name_ms.len = name_b.length(); + name_ms.data = static_cast(malloc(name_ms.len)); + memcpy(name_ms.data, name_b.data(), name_ms.len); + struct miqt_string sigval1 = name_ms; + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval2 = const_cast(&value_ret); + const QString context_ret = context; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray context_b = context_ret.toUtf8(); + struct miqt_string context_ms; + context_ms.len = context_b.length(); + context_ms.data = static_cast(malloc(context_ms.len)); + memcpy(context_ms.data, context_b.data(), context_ms.len); + struct miqt_string sigval3 = context_ms; + bool callback_return_value = miqt_exec_callback_QScxmlDataModel_setScxmlProperty(this, handle__setScxmlProperty, sigval1, sigval2, sigval3); + return callback_return_value; + } + + // 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 QScxmlDataModel::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QScxmlDataModel_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QScxmlDataModel_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 QScxmlDataModel::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QScxmlDataModel_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QScxmlDataModel_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) { + QScxmlDataModel::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QScxmlDataModel_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QScxmlDataModel_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) { + QScxmlDataModel::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QScxmlDataModel_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QScxmlDataModel_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) { + QScxmlDataModel::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QScxmlDataModel_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QScxmlDataModel_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) { + QScxmlDataModel::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlDataModel_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QScxmlDataModel_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) { + QScxmlDataModel::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlDataModel_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QScxmlDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QScxmlDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QScxmlDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QScxmlDataModel* QScxmlDataModel_new() { + return new (std::nothrow) MiqtVirtualQScxmlDataModel(); +} + +QScxmlDataModel* QScxmlDataModel_new2(QObject* parent) { + return new (std::nothrow) MiqtVirtualQScxmlDataModel(parent); +} + +void QScxmlDataModel_virtbase(QScxmlDataModel* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QScxmlDataModel_metaObject(const QScxmlDataModel* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QScxmlDataModel_metacast(QScxmlDataModel* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QScxmlDataModel_tr(const char* s) { + QString _ret = QScxmlDataModel::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; +} + +QScxmlDataModel* QScxmlDataModel_createScxmlDataModel(struct miqt_string pluginKey) { + QString pluginKey_QString = QString::fromUtf8(pluginKey.data, pluginKey.len); + return QScxmlDataModel::createScxmlDataModel(pluginKey_QString); +} + +void QScxmlDataModel_setStateMachine(QScxmlDataModel* self, QScxmlStateMachine* stateMachine) { + self->setStateMachine(stateMachine); +} + +QScxmlStateMachine* QScxmlDataModel_stateMachine(const QScxmlDataModel* self) { + return self->stateMachine(); +} + +bool QScxmlDataModel_setup(QScxmlDataModel* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues) { + QVariantMap initialDataValues_QMap; + struct miqt_string* initialDataValues_karr = static_cast(initialDataValues.keys); + QVariant** initialDataValues_varr = static_cast(initialDataValues.values); + for(size_t i = 0; i < initialDataValues.len; ++i) { + QString initialDataValues_karr_i_QString = QString::fromUtf8(initialDataValues_karr[i].data, initialDataValues_karr[i].len); + initialDataValues_QMap[initialDataValues_karr_i_QString] = *(initialDataValues_varr[i]); + } + return self->setup(initialDataValues_QMap); +} + +struct miqt_string QScxmlDataModel_evaluateToString(QScxmlDataModel* self, int id, bool* ok) { + QString _ret = self->evaluateToString(static_cast(id), ok); + // 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 QScxmlDataModel_evaluateToBool(QScxmlDataModel* self, int id, bool* ok) { + return self->evaluateToBool(static_cast(id), ok); +} + +QVariant* QScxmlDataModel_evaluateToVariant(QScxmlDataModel* self, int id, bool* ok) { + return new QVariant(self->evaluateToVariant(static_cast(id), ok)); +} + +void QScxmlDataModel_evaluateToVoid(QScxmlDataModel* self, int id, bool* ok) { + self->evaluateToVoid(static_cast(id), ok); +} + +void QScxmlDataModel_evaluateAssignment(QScxmlDataModel* self, int id, bool* ok) { + self->evaluateAssignment(static_cast(id), ok); +} + +void QScxmlDataModel_evaluateInitialization(QScxmlDataModel* self, int id, bool* ok) { + self->evaluateInitialization(static_cast(id), ok); +} + +void QScxmlDataModel_evaluateForeach(QScxmlDataModel* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body) { + self->evaluateForeach(static_cast(id), ok, body); +} + +void QScxmlDataModel_setScxmlEvent(QScxmlDataModel* self, QScxmlEvent* event) { + self->setScxmlEvent(*event); +} + +QVariant* QScxmlDataModel_scxmlProperty(const QScxmlDataModel* self, struct miqt_string name) { + QString name_QString = QString::fromUtf8(name.data, name.len); + return new QVariant(self->scxmlProperty(name_QString)); +} + +bool QScxmlDataModel_hasScxmlProperty(const QScxmlDataModel* self, struct miqt_string name) { + QString name_QString = QString::fromUtf8(name.data, name.len); + return self->hasScxmlProperty(name_QString); +} + +bool QScxmlDataModel_setScxmlProperty(QScxmlDataModel* self, struct miqt_string name, QVariant* value, struct miqt_string context) { + QString name_QString = QString::fromUtf8(name.data, name.len); + QString context_QString = QString::fromUtf8(context.data, context.len); + return self->setScxmlProperty(name_QString, *value, context_QString); +} + +void QScxmlDataModel_stateMachineChanged(QScxmlDataModel* self, QScxmlStateMachine* stateMachine) { + self->stateMachineChanged(stateMachine); +} + +void QScxmlDataModel_connect_stateMachineChanged(QScxmlDataModel* self, intptr_t slot) { + QScxmlDataModel::connect(self, static_cast(&QScxmlDataModel::stateMachineChanged), self, [=](QScxmlStateMachine* stateMachine) { + QScxmlStateMachine* sigval1 = stateMachine; + miqt_exec_callback_QScxmlDataModel_stateMachineChanged(slot, sigval1); + }); +} + +struct miqt_string QScxmlDataModel_tr2(const char* s, const char* c) { + QString _ret = QScxmlDataModel::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 QScxmlDataModel_tr3(const char* s, const char* c, int n) { + QString _ret = QScxmlDataModel::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 QScxmlDataModel_override_virtual_setup(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setup = slot; + return true; +} + +bool QScxmlDataModel_override_virtual_evaluateToString(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateToString = slot; + return true; +} + +bool QScxmlDataModel_override_virtual_evaluateToBool(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateToBool = slot; + return true; +} + +bool QScxmlDataModel_override_virtual_evaluateToVariant(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateToVariant = slot; + return true; +} + +bool QScxmlDataModel_override_virtual_evaluateToVoid(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateToVoid = slot; + return true; +} + +bool QScxmlDataModel_override_virtual_evaluateAssignment(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateAssignment = slot; + return true; +} + +bool QScxmlDataModel_override_virtual_evaluateInitialization(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateInitialization = slot; + return true; +} + +bool QScxmlDataModel_override_virtual_evaluateForeach(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateForeach = slot; + return true; +} + +bool QScxmlDataModel_override_virtual_setScxmlEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setScxmlEvent = slot; + return true; +} + +bool QScxmlDataModel_override_virtual_scxmlProperty(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__scxmlProperty = slot; + return true; +} + +bool QScxmlDataModel_override_virtual_hasScxmlProperty(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__hasScxmlProperty = slot; + return true; +} + +bool QScxmlDataModel_override_virtual_setScxmlProperty(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setScxmlProperty = slot; + return true; +} + +bool QScxmlDataModel_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QScxmlDataModel_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QScxmlDataModel::event(event); +} + +bool QScxmlDataModel_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QScxmlDataModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QScxmlDataModel::eventFilter(watched, event); +} + +bool QScxmlDataModel_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QScxmlDataModel_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QScxmlDataModel::timerEvent(event); +} + +bool QScxmlDataModel_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QScxmlDataModel_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QScxmlDataModel::childEvent(event); +} + +bool QScxmlDataModel_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QScxmlDataModel_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QScxmlDataModel::customEvent(event); +} + +bool QScxmlDataModel_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QScxmlDataModel_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlDataModel::connectNotify(*signal); +} + +bool QScxmlDataModel_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QScxmlDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlDataModel::disconnectNotify(*signal); +} + +QObject* QScxmlDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QScxmlDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QScxmlDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QScxmlDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QScxmlDataModel_delete(QScxmlDataModel* self) { + delete self; +} + +class MiqtVirtualQScxmlDataModelForeachLoopBody final : public QScxmlDataModel::ForeachLoopBody { +public: + + MiqtVirtualQScxmlDataModelForeachLoopBody(): QScxmlDataModel::ForeachLoopBody() {} + + virtual ~MiqtVirtualQScxmlDataModelForeachLoopBody() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__run = 0; + + // Subclass to allow providing a Go implementation + virtual void run(bool* ok) override { + if (handle__run == 0) { + return; // Pure virtual, there is no base we can call + } + + bool* sigval1 = ok; + miqt_exec_callback_QScxmlDataModel__ForeachLoopBody_run(this, handle__run, sigval1); + + } + +}; + +QScxmlDataModel__ForeachLoopBody* QScxmlDataModel__ForeachLoopBody_new() { + return new (std::nothrow) MiqtVirtualQScxmlDataModelForeachLoopBody(); +} + +void QScxmlDataModel__ForeachLoopBody_run(QScxmlDataModel__ForeachLoopBody* self, bool* ok) { + self->run(ok); +} + +bool QScxmlDataModel__ForeachLoopBody_override_virtual_run(void* self, intptr_t slot) { + MiqtVirtualQScxmlDataModelForeachLoopBody* self_cast = dynamic_cast( (QScxmlDataModel::ForeachLoopBody*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__run = slot; + return true; +} + +void QScxmlDataModel__ForeachLoopBody_delete(QScxmlDataModel__ForeachLoopBody* self) { + delete self; +} + diff --git a/qt6/scxml/gen_qscxmldatamodel.go b/qt6/scxml/gen_qscxmldatamodel.go new file mode 100644 index 000000000..422ad8a39 --- /dev/null +++ b/qt6/scxml/gen_qscxmldatamodel.go @@ -0,0 +1,871 @@ +package scxml + +/* + +#include "gen_qscxmldatamodel.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QScxmlDataModel struct { + h *C.QScxmlDataModel + *qt6.QObject +} + +func (this *QScxmlDataModel) cPointer() *C.QScxmlDataModel { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlDataModel) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlDataModel constructs the type using only CGO pointers. +func newQScxmlDataModel(h *C.QScxmlDataModel) *QScxmlDataModel { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QScxmlDataModel_virtbase(h, &outptr_QObject) + + return &QScxmlDataModel{h: h, + QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQScxmlDataModel constructs the type using only unsafe pointers. +func UnsafeNewQScxmlDataModel(h unsafe.Pointer) *QScxmlDataModel { + return newQScxmlDataModel((*C.QScxmlDataModel)(h)) +} + +// NewQScxmlDataModel constructs a new QScxmlDataModel object. +func NewQScxmlDataModel() *QScxmlDataModel { + + return newQScxmlDataModel(C.QScxmlDataModel_new()) +} + +// NewQScxmlDataModel2 constructs a new QScxmlDataModel object. +func NewQScxmlDataModel2(parent *qt6.QObject) *QScxmlDataModel { + + return newQScxmlDataModel(C.QScxmlDataModel_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QScxmlDataModel) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlDataModel_metaObject(this.h))) +} + +func (this *QScxmlDataModel) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QScxmlDataModel_metacast(this.h, param1_Cstring)) +} + +func QScxmlDataModel_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QScxmlDataModel_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QScxmlDataModel_CreateScxmlDataModel(pluginKey string) *QScxmlDataModel { + pluginKey_ms := C.struct_miqt_string{} + pluginKey_ms.data = C.CString(pluginKey) + pluginKey_ms.len = C.size_t(len(pluginKey)) + defer C.free(unsafe.Pointer(pluginKey_ms.data)) + return newQScxmlDataModel(C.QScxmlDataModel_createScxmlDataModel(pluginKey_ms)) +} + +func (this *QScxmlDataModel) SetStateMachine(stateMachine *QScxmlStateMachine) { + C.QScxmlDataModel_setStateMachine(this.h, stateMachine.cPointer()) +} + +func (this *QScxmlDataModel) StateMachine() *QScxmlStateMachine { + return newQScxmlStateMachine(C.QScxmlDataModel_stateMachine(this.h)) +} + +func (this *QScxmlDataModel) Setup(initialDataValues map[string]qt6.QVariant) bool { + initialDataValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialDataValues)))) + defer C.free(unsafe.Pointer(initialDataValues_Keys_CArray)) + initialDataValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialDataValues)))) + defer C.free(unsafe.Pointer(initialDataValues_Values_CArray)) + initialDataValues_ctr := 0 + for initialDataValues_k, initialDataValues_v := range initialDataValues { + initialDataValues_k_ms := C.struct_miqt_string{} + initialDataValues_k_ms.data = C.CString(initialDataValues_k) + initialDataValues_k_ms.len = C.size_t(len(initialDataValues_k)) + defer C.free(unsafe.Pointer(initialDataValues_k_ms.data)) + initialDataValues_Keys_CArray[initialDataValues_ctr] = initialDataValues_k_ms + initialDataValues_Values_CArray[initialDataValues_ctr] = (*C.QVariant)(initialDataValues_v.UnsafePointer()) + initialDataValues_ctr++ + } + initialDataValues_mm := C.struct_miqt_map{ + len: C.size_t(len(initialDataValues)), + keys: unsafe.Pointer(initialDataValues_Keys_CArray), + values: unsafe.Pointer(initialDataValues_Values_CArray), + } + return (bool)(C.QScxmlDataModel_setup(this.h, initialDataValues_mm)) +} + +func (this *QScxmlDataModel) EvaluateToString(id int, ok *bool) string { + var _ms C.struct_miqt_string = C.QScxmlDataModel_evaluateToString(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlDataModel) EvaluateToBool(id int, ok *bool) bool { + return (bool)(C.QScxmlDataModel_evaluateToBool(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok)))) +} + +func (this *QScxmlDataModel) EvaluateToVariant(id int, ok *bool) *qt6.QVariant { + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlDataModel_evaluateToVariant(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QScxmlDataModel) EvaluateToVoid(id int, ok *bool) { + C.QScxmlDataModel_evaluateToVoid(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) +} + +func (this *QScxmlDataModel) EvaluateAssignment(id int, ok *bool) { + C.QScxmlDataModel_evaluateAssignment(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) +} + +func (this *QScxmlDataModel) EvaluateInitialization(id int, ok *bool) { + C.QScxmlDataModel_evaluateInitialization(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) +} + +func (this *QScxmlDataModel) EvaluateForeach(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody) { + C.QScxmlDataModel_evaluateForeach(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok)), body.cPointer()) +} + +func (this *QScxmlDataModel) SetScxmlEvent(event *QScxmlEvent) { + C.QScxmlDataModel_setScxmlEvent(this.h, event.cPointer()) +} + +func (this *QScxmlDataModel) ScxmlProperty(name string) *qt6.QVariant { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlDataModel_scxmlProperty(this.h, name_ms))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QScxmlDataModel) HasScxmlProperty(name string) bool { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + return (bool)(C.QScxmlDataModel_hasScxmlProperty(this.h, name_ms)) +} + +func (this *QScxmlDataModel) SetScxmlProperty(name string, value *qt6.QVariant, context string) bool { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + context_ms := C.struct_miqt_string{} + context_ms.data = C.CString(context) + context_ms.len = C.size_t(len(context)) + defer C.free(unsafe.Pointer(context_ms.data)) + return (bool)(C.QScxmlDataModel_setScxmlProperty(this.h, name_ms, (*C.QVariant)(value.UnsafePointer()), context_ms)) +} + +func (this *QScxmlDataModel) StateMachineChanged(stateMachine *QScxmlStateMachine) { + C.QScxmlDataModel_stateMachineChanged(this.h, stateMachine.cPointer()) +} +func (this *QScxmlDataModel) OnStateMachineChanged(slot func(stateMachine *QScxmlStateMachine)) { + C.QScxmlDataModel_connect_stateMachineChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QScxmlDataModel_stateMachineChanged +func miqt_exec_callback_QScxmlDataModel_stateMachineChanged(cb C.intptr_t, stateMachine *C.QScxmlStateMachine) { + gofunc, ok := cgo.Handle(cb).Value().(func(stateMachine *QScxmlStateMachine)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQScxmlStateMachine(stateMachine) + + gofunc(slotval1) +} + +func QScxmlDataModel_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.QScxmlDataModel_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QScxmlDataModel_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.QScxmlDataModel_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 +} + +// Sender can only be called from a QScxmlDataModel that was directly constructed. +func (this *QScxmlDataModel) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlDataModel_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 QScxmlDataModel that was directly constructed. +func (this *QScxmlDataModel) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QScxmlDataModel_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 QScxmlDataModel that was directly constructed. +func (this *QScxmlDataModel) 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.QScxmlDataModel_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 QScxmlDataModel that was directly constructed. +func (this *QScxmlDataModel) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QScxmlDataModel_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 *QScxmlDataModel) OnSetup(slot func(initialDataValues map[string]qt6.QVariant) bool) { + ok := C.QScxmlDataModel_override_virtual_setup(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel_setup +func miqt_exec_callback_QScxmlDataModel_setup(self *C.QScxmlDataModel, cb C.intptr_t, initialDataValues C.struct_miqt_map) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(initialDataValues map[string]qt6.QVariant) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var initialDataValues_mm C.struct_miqt_map = initialDataValues + initialDataValues_ret := make(map[string]qt6.QVariant, int(initialDataValues_mm.len)) + initialDataValues_Keys := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(initialDataValues_mm.keys)) + initialDataValues_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(initialDataValues_mm.values)) + for i := 0; i < int(initialDataValues_mm.len); i++ { + var initialDataValues_mapkey_ms C.struct_miqt_string = initialDataValues_Keys[i] + initialDataValues_mapkey_ret := C.GoStringN(initialDataValues_mapkey_ms.data, C.int(int64(initialDataValues_mapkey_ms.len))) + C.free(unsafe.Pointer(initialDataValues_mapkey_ms.data)) + initialDataValues_entry_Key := initialDataValues_mapkey_ret + initialDataValues_mapval_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(initialDataValues_Values[i])) + initialDataValues_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + initialDataValues_entry_Value := *initialDataValues_mapval_goptr + + initialDataValues_ret[initialDataValues_entry_Key] = initialDataValues_entry_Value + } + slotval1 := initialDataValues_ret + + virtualReturn := gofunc(slotval1) + + return (C.bool)(virtualReturn) + +} +func (this *QScxmlDataModel) OnEvaluateToString(slot func(id int, ok *bool) string) { + ok := C.QScxmlDataModel_override_virtual_evaluateToString(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel_evaluateToString +func miqt_exec_callback_QScxmlDataModel_evaluateToString(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool) C.struct_miqt_string { + gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool) string) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + virtualReturn := gofunc(slotval1, slotval2) + virtualReturn_ms := C.struct_miqt_string{} + virtualReturn_ms.data = C.CString(virtualReturn) + virtualReturn_ms.len = C.size_t(len(virtualReturn)) + defer C.free(unsafe.Pointer(virtualReturn_ms.data)) + + return virtualReturn_ms + +} +func (this *QScxmlDataModel) OnEvaluateToBool(slot func(id int, ok *bool) bool) { + ok := C.QScxmlDataModel_override_virtual_evaluateToBool(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel_evaluateToBool +func miqt_exec_callback_QScxmlDataModel_evaluateToBool(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + virtualReturn := gofunc(slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} +func (this *QScxmlDataModel) OnEvaluateToVariant(slot func(id int, ok *bool) *qt6.QVariant) { + ok := C.QScxmlDataModel_override_virtual_evaluateToVariant(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel_evaluateToVariant +func miqt_exec_callback_QScxmlDataModel_evaluateToVariant(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool) *qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + virtualReturn := gofunc(slotval1, slotval2) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} +func (this *QScxmlDataModel) OnEvaluateToVoid(slot func(id int, ok *bool)) { + ok := C.QScxmlDataModel_override_virtual_evaluateToVoid(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel_evaluateToVoid +func miqt_exec_callback_QScxmlDataModel_evaluateToVoid(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + gofunc(slotval1, slotval2) + +} +func (this *QScxmlDataModel) OnEvaluateAssignment(slot func(id int, ok *bool)) { + ok := C.QScxmlDataModel_override_virtual_evaluateAssignment(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel_evaluateAssignment +func miqt_exec_callback_QScxmlDataModel_evaluateAssignment(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + gofunc(slotval1, slotval2) + +} +func (this *QScxmlDataModel) OnEvaluateInitialization(slot func(id int, ok *bool)) { + ok := C.QScxmlDataModel_override_virtual_evaluateInitialization(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel_evaluateInitialization +func miqt_exec_callback_QScxmlDataModel_evaluateInitialization(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + gofunc(slotval1, slotval2) + +} +func (this *QScxmlDataModel) OnEvaluateForeach(slot func(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody)) { + ok := C.QScxmlDataModel_override_virtual_evaluateForeach(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel_evaluateForeach +func miqt_exec_callback_QScxmlDataModel_evaluateForeach(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool, body *C.QScxmlDataModel__ForeachLoopBody) { + gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + slotval3 := newQScxmlDataModel__ForeachLoopBody(body) + + gofunc(slotval1, slotval2, slotval3) + +} +func (this *QScxmlDataModel) OnSetScxmlEvent(slot func(event *QScxmlEvent)) { + ok := C.QScxmlDataModel_override_virtual_setScxmlEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel_setScxmlEvent +func miqt_exec_callback_QScxmlDataModel_setScxmlEvent(self *C.QScxmlDataModel, cb C.intptr_t, event *C.QScxmlEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(event *QScxmlEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQScxmlEvent(event) + + gofunc(slotval1) + +} +func (this *QScxmlDataModel) OnScxmlProperty(slot func(name string) *qt6.QVariant) { + ok := C.QScxmlDataModel_override_virtual_scxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel_scxmlProperty +func miqt_exec_callback_QScxmlDataModel_scxmlProperty(self *C.QScxmlDataModel, cb C.intptr_t, name C.struct_miqt_string) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(name string) *qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var name_ms C.struct_miqt_string = name + name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) + C.free(unsafe.Pointer(name_ms.data)) + slotval1 := name_ret + + virtualReturn := gofunc(slotval1) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} +func (this *QScxmlDataModel) OnHasScxmlProperty(slot func(name string) bool) { + ok := C.QScxmlDataModel_override_virtual_hasScxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel_hasScxmlProperty +func miqt_exec_callback_QScxmlDataModel_hasScxmlProperty(self *C.QScxmlDataModel, cb C.intptr_t, name C.struct_miqt_string) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(name string) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var name_ms C.struct_miqt_string = name + name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) + C.free(unsafe.Pointer(name_ms.data)) + slotval1 := name_ret + + virtualReturn := gofunc(slotval1) + + return (C.bool)(virtualReturn) + +} +func (this *QScxmlDataModel) OnSetScxmlProperty(slot func(name string, value *qt6.QVariant, context string) bool) { + ok := C.QScxmlDataModel_override_virtual_setScxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel_setScxmlProperty +func miqt_exec_callback_QScxmlDataModel_setScxmlProperty(self *C.QScxmlDataModel, cb C.intptr_t, name C.struct_miqt_string, value *C.QVariant, context C.struct_miqt_string) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(name string, value *qt6.QVariant, context string) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var name_ms C.struct_miqt_string = name + name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) + C.free(unsafe.Pointer(name_ms.data)) + slotval1 := name_ret + slotval2 := qt6.UnsafeNewQVariant(unsafe.Pointer(value)) + + var context_ms C.struct_miqt_string = context + context_ret := C.GoStringN(context_ms.data, C.int(int64(context_ms.len))) + C.free(unsafe.Pointer(context_ms.data)) + slotval3 := context_ret + + virtualReturn := gofunc(slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlDataModel) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QScxmlDataModel_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlDataModel) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QScxmlDataModel_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_QScxmlDataModel_event +func miqt_exec_callback_QScxmlDataModel_event(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlDataModel) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QScxmlDataModel_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlDataModel) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QScxmlDataModel_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_QScxmlDataModel_eventFilter +func miqt_exec_callback_QScxmlDataModel_eventFilter(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlDataModel) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QScxmlDataModel_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QScxmlDataModel) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QScxmlDataModel_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_QScxmlDataModel_timerEvent +func miqt_exec_callback_QScxmlDataModel_timerEvent(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QScxmlDataModel) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QScxmlDataModel_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QScxmlDataModel) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QScxmlDataModel_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_QScxmlDataModel_childEvent +func miqt_exec_callback_QScxmlDataModel_childEvent(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QScxmlDataModel) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QScxmlDataModel_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QScxmlDataModel) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QScxmlDataModel_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_QScxmlDataModel_customEvent +func miqt_exec_callback_QScxmlDataModel_customEvent(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QScxmlDataModel) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlDataModel_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlDataModel) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlDataModel_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_QScxmlDataModel_connectNotify +func miqt_exec_callback_QScxmlDataModel_connectNotify(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QScxmlDataModel) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlDataModel_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlDataModel) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlDataModel_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_QScxmlDataModel_disconnectNotify +func miqt_exec_callback_QScxmlDataModel_disconnectNotify(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QScxmlDataModel) Delete() { + C.QScxmlDataModel_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 *QScxmlDataModel) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlDataModel) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type QScxmlDataModel__ForeachLoopBody struct { + h *C.QScxmlDataModel__ForeachLoopBody +} + +func (this *QScxmlDataModel__ForeachLoopBody) cPointer() *C.QScxmlDataModel__ForeachLoopBody { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlDataModel__ForeachLoopBody) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlDataModel__ForeachLoopBody constructs the type using only CGO pointers. +func newQScxmlDataModel__ForeachLoopBody(h *C.QScxmlDataModel__ForeachLoopBody) *QScxmlDataModel__ForeachLoopBody { + if h == nil { + return nil + } + + return &QScxmlDataModel__ForeachLoopBody{h: h} +} + +// UnsafeNewQScxmlDataModel__ForeachLoopBody constructs the type using only unsafe pointers. +func UnsafeNewQScxmlDataModel__ForeachLoopBody(h unsafe.Pointer) *QScxmlDataModel__ForeachLoopBody { + return newQScxmlDataModel__ForeachLoopBody((*C.QScxmlDataModel__ForeachLoopBody)(h)) +} + +// NewQScxmlDataModel__ForeachLoopBody constructs a new QScxmlDataModel::ForeachLoopBody object. +func NewQScxmlDataModel__ForeachLoopBody() *QScxmlDataModel__ForeachLoopBody { + + return newQScxmlDataModel__ForeachLoopBody(C.QScxmlDataModel__ForeachLoopBody_new()) +} + +func (this *QScxmlDataModel__ForeachLoopBody) Run(ok *bool) { + C.QScxmlDataModel__ForeachLoopBody_run(this.h, (*C.bool)(unsafe.Pointer(ok))) +} +func (this *QScxmlDataModel__ForeachLoopBody) OnRun(slot func(ok *bool)) { + ok := C.QScxmlDataModel__ForeachLoopBody_override_virtual_run(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDataModel__ForeachLoopBody_run +func miqt_exec_callback_QScxmlDataModel__ForeachLoopBody_run(self *C.QScxmlDataModel__ForeachLoopBody, cb C.intptr_t, ok *C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(ok *bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (*bool)(unsafe.Pointer(ok)) + + gofunc(slotval1) + +} + +// Delete this object from C++ memory. +func (this *QScxmlDataModel__ForeachLoopBody) Delete() { + C.QScxmlDataModel__ForeachLoopBody_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 *QScxmlDataModel__ForeachLoopBody) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlDataModel__ForeachLoopBody) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/scxml/gen_qscxmldatamodel.h b/qt6/scxml/gen_qscxmldatamodel.h new file mode 100644 index 000000000..825df0830 --- /dev/null +++ b/qt6/scxml/gen_qscxmldatamodel.h @@ -0,0 +1,131 @@ +#pragma once +#ifndef MIQT_QT6_SCXML_GEN_QSCXMLDATAMODEL_H +#define MIQT_QT6_SCXML_GEN_QSCXMLDATAMODEL_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 QScxmlDataModel; +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlDataModel__ForeachLoopBody) +typedef QScxmlDataModel::ForeachLoopBody QScxmlDataModel__ForeachLoopBody; +#else +class QScxmlDataModel__ForeachLoopBody; +#endif +class QScxmlEvent; +class QScxmlStateMachine; +class QTimerEvent; +class QVariant; +#else +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QScxmlDataModel QScxmlDataModel; +typedef struct QScxmlDataModel__ForeachLoopBody QScxmlDataModel__ForeachLoopBody; +typedef struct QScxmlEvent QScxmlEvent; +typedef struct QScxmlStateMachine QScxmlStateMachine; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +#endif + +QScxmlDataModel* QScxmlDataModel_new(); +QScxmlDataModel* QScxmlDataModel_new2(QObject* parent); +void QScxmlDataModel_virtbase(QScxmlDataModel* src, QObject** outptr_QObject); +QMetaObject* QScxmlDataModel_metaObject(const QScxmlDataModel* self); +void* QScxmlDataModel_metacast(QScxmlDataModel* self, const char* param1); +struct miqt_string QScxmlDataModel_tr(const char* s); +QScxmlDataModel* QScxmlDataModel_createScxmlDataModel(struct miqt_string pluginKey); +void QScxmlDataModel_setStateMachine(QScxmlDataModel* self, QScxmlStateMachine* stateMachine); +QScxmlStateMachine* QScxmlDataModel_stateMachine(const QScxmlDataModel* self); +bool QScxmlDataModel_setup(QScxmlDataModel* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); +struct miqt_string QScxmlDataModel_evaluateToString(QScxmlDataModel* self, int id, bool* ok); +bool QScxmlDataModel_evaluateToBool(QScxmlDataModel* self, int id, bool* ok); +QVariant* QScxmlDataModel_evaluateToVariant(QScxmlDataModel* self, int id, bool* ok); +void QScxmlDataModel_evaluateToVoid(QScxmlDataModel* self, int id, bool* ok); +void QScxmlDataModel_evaluateAssignment(QScxmlDataModel* self, int id, bool* ok); +void QScxmlDataModel_evaluateInitialization(QScxmlDataModel* self, int id, bool* ok); +void QScxmlDataModel_evaluateForeach(QScxmlDataModel* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); +void QScxmlDataModel_setScxmlEvent(QScxmlDataModel* self, QScxmlEvent* event); +QVariant* QScxmlDataModel_scxmlProperty(const QScxmlDataModel* self, struct miqt_string name); +bool QScxmlDataModel_hasScxmlProperty(const QScxmlDataModel* self, struct miqt_string name); +bool QScxmlDataModel_setScxmlProperty(QScxmlDataModel* self, struct miqt_string name, QVariant* value, struct miqt_string context); +void QScxmlDataModel_stateMachineChanged(QScxmlDataModel* self, QScxmlStateMachine* stateMachine); +void QScxmlDataModel_connect_stateMachineChanged(QScxmlDataModel* self, intptr_t slot); +struct miqt_string QScxmlDataModel_tr2(const char* s, const char* c); +struct miqt_string QScxmlDataModel_tr3(const char* s, const char* c, int n); + +bool QScxmlDataModel_override_virtual_setup(void* self, intptr_t slot); +bool QScxmlDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); +bool QScxmlDataModel_override_virtual_evaluateToString(void* self, intptr_t slot); +struct miqt_string QScxmlDataModel_virtualbase_evaluateToString(void* self, int id, bool* ok); +bool QScxmlDataModel_override_virtual_evaluateToBool(void* self, intptr_t slot); +bool QScxmlDataModel_virtualbase_evaluateToBool(void* self, int id, bool* ok); +bool QScxmlDataModel_override_virtual_evaluateToVariant(void* self, intptr_t slot); +QVariant* QScxmlDataModel_virtualbase_evaluateToVariant(void* self, int id, bool* ok); +bool QScxmlDataModel_override_virtual_evaluateToVoid(void* self, intptr_t slot); +void QScxmlDataModel_virtualbase_evaluateToVoid(void* self, int id, bool* ok); +bool QScxmlDataModel_override_virtual_evaluateAssignment(void* self, intptr_t slot); +void QScxmlDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok); +bool QScxmlDataModel_override_virtual_evaluateInitialization(void* self, intptr_t slot); +void QScxmlDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok); +bool QScxmlDataModel_override_virtual_evaluateForeach(void* self, intptr_t slot); +void QScxmlDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); +bool QScxmlDataModel_override_virtual_setScxmlEvent(void* self, intptr_t slot); +void QScxmlDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* event); +bool QScxmlDataModel_override_virtual_scxmlProperty(void* self, intptr_t slot); +QVariant* QScxmlDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name); +bool QScxmlDataModel_override_virtual_hasScxmlProperty(void* self, intptr_t slot); +bool QScxmlDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name); +bool QScxmlDataModel_override_virtual_setScxmlProperty(void* self, intptr_t slot); +bool QScxmlDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context); +bool QScxmlDataModel_override_virtual_event(void* self, intptr_t slot); +bool QScxmlDataModel_virtualbase_event(void* self, QEvent* event); +bool QScxmlDataModel_override_virtual_eventFilter(void* self, intptr_t slot); +bool QScxmlDataModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QScxmlDataModel_override_virtual_timerEvent(void* self, intptr_t slot); +void QScxmlDataModel_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QScxmlDataModel_override_virtual_childEvent(void* self, intptr_t slot); +void QScxmlDataModel_virtualbase_childEvent(void* self, QChildEvent* event); +bool QScxmlDataModel_override_virtual_customEvent(void* self, intptr_t slot); +void QScxmlDataModel_virtualbase_customEvent(void* self, QEvent* event); +bool QScxmlDataModel_override_virtual_connectNotify(void* self, intptr_t slot); +void QScxmlDataModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QScxmlDataModel_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QScxmlDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QScxmlDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QScxmlDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QScxmlDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QScxmlDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QScxmlDataModel_delete(QScxmlDataModel* self); + +QScxmlDataModel__ForeachLoopBody* QScxmlDataModel__ForeachLoopBody_new(); +void QScxmlDataModel__ForeachLoopBody_run(QScxmlDataModel__ForeachLoopBody* self, bool* ok); + +bool QScxmlDataModel__ForeachLoopBody_override_virtual_run(void* self, intptr_t slot); +void QScxmlDataModel__ForeachLoopBody_virtualbase_run(void* self, bool* ok); + +void QScxmlDataModel__ForeachLoopBody_delete(QScxmlDataModel__ForeachLoopBody* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/scxml/gen_qscxmlerror.cpp b/qt6/scxml/gen_qscxmlerror.cpp new file mode 100644 index 000000000..34592426b --- /dev/null +++ b/qt6/scxml/gen_qscxmlerror.cpp @@ -0,0 +1,82 @@ +#include +#include +#include +#include +#include +#include "gen_qscxmlerror.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +QScxmlError* QScxmlError_new() { + return new (std::nothrow) QScxmlError(); +} + +QScxmlError* QScxmlError_new2(struct miqt_string fileName, int line, int column, struct miqt_string description) { + QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); + QString description_QString = QString::fromUtf8(description.data, description.len); + return new (std::nothrow) QScxmlError(fileName_QString, static_cast(line), static_cast(column), description_QString); +} + +QScxmlError* QScxmlError_new3(QScxmlError* param1) { + return new (std::nothrow) QScxmlError(*param1); +} + +void QScxmlError_operatorAssign(QScxmlError* self, QScxmlError* param1) { + self->operator=(*param1); +} + +bool QScxmlError_isValid(const QScxmlError* self) { + return self->isValid(); +} + +struct miqt_string QScxmlError_fileName(const QScxmlError* self) { + QString _ret = self->fileName(); + // 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 QScxmlError_line(const QScxmlError* self) { + return self->line(); +} + +int QScxmlError_column(const QScxmlError* self) { + return self->column(); +} + +struct miqt_string QScxmlError_description(const QScxmlError* self) { + QString _ret = self->description(); + // 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 QScxmlError_toString(const QScxmlError* 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 QScxmlError_delete(QScxmlError* self) { + delete self; +} + diff --git a/qt6/scxml/gen_qscxmlerror.go b/qt6/scxml/gen_qscxmlerror.go new file mode 100644 index 000000000..5bfabfa55 --- /dev/null +++ b/qt6/scxml/gen_qscxmlerror.go @@ -0,0 +1,123 @@ +package scxml + +/* + +#include "gen_qscxmlerror.h" +#include + +*/ +import "C" + +import ( + "runtime" + "unsafe" +) + +type QScxmlError struct { + h *C.QScxmlError +} + +func (this *QScxmlError) cPointer() *C.QScxmlError { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlError) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlError constructs the type using only CGO pointers. +func newQScxmlError(h *C.QScxmlError) *QScxmlError { + if h == nil { + return nil + } + + return &QScxmlError{h: h} +} + +// UnsafeNewQScxmlError constructs the type using only unsafe pointers. +func UnsafeNewQScxmlError(h unsafe.Pointer) *QScxmlError { + return newQScxmlError((*C.QScxmlError)(h)) +} + +// NewQScxmlError constructs a new QScxmlError object. +func NewQScxmlError() *QScxmlError { + + return newQScxmlError(C.QScxmlError_new()) +} + +// NewQScxmlError2 constructs a new QScxmlError object. +func NewQScxmlError2(fileName string, line int, column int, description string) *QScxmlError { + 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)) + description_ms := C.struct_miqt_string{} + description_ms.data = C.CString(description) + description_ms.len = C.size_t(len(description)) + defer C.free(unsafe.Pointer(description_ms.data)) + + return newQScxmlError(C.QScxmlError_new2(fileName_ms, (C.int)(line), (C.int)(column), description_ms)) +} + +// NewQScxmlError3 constructs a new QScxmlError object. +func NewQScxmlError3(param1 *QScxmlError) *QScxmlError { + + return newQScxmlError(C.QScxmlError_new3(param1.cPointer())) +} + +func (this *QScxmlError) OperatorAssign(param1 *QScxmlError) { + C.QScxmlError_operatorAssign(this.h, param1.cPointer()) +} + +func (this *QScxmlError) IsValid() bool { + return (bool)(C.QScxmlError_isValid(this.h)) +} + +func (this *QScxmlError) FileName() string { + var _ms C.struct_miqt_string = C.QScxmlError_fileName(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlError) Line() int { + return (int)(C.QScxmlError_line(this.h)) +} + +func (this *QScxmlError) Column() int { + return (int)(C.QScxmlError_column(this.h)) +} + +func (this *QScxmlError) Description() string { + var _ms C.struct_miqt_string = C.QScxmlError_description(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlError) ToString() string { + var _ms C.struct_miqt_string = C.QScxmlError_toString(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +// Delete this object from C++ memory. +func (this *QScxmlError) Delete() { + C.QScxmlError_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 *QScxmlError) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlError) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/scxml/gen_qscxmlerror.h b/qt6/scxml/gen_qscxmlerror.h new file mode 100644 index 000000000..e03d963c9 --- /dev/null +++ b/qt6/scxml/gen_qscxmlerror.h @@ -0,0 +1,40 @@ +#pragma once +#ifndef MIQT_QT6_SCXML_GEN_QSCXMLERROR_H +#define MIQT_QT6_SCXML_GEN_QSCXMLERROR_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QScxmlError; +#else +typedef struct QScxmlError QScxmlError; +#endif + +QScxmlError* QScxmlError_new(); +QScxmlError* QScxmlError_new2(struct miqt_string fileName, int line, int column, struct miqt_string description); +QScxmlError* QScxmlError_new3(QScxmlError* param1); +void QScxmlError_operatorAssign(QScxmlError* self, QScxmlError* param1); +bool QScxmlError_isValid(const QScxmlError* self); +struct miqt_string QScxmlError_fileName(const QScxmlError* self); +int QScxmlError_line(const QScxmlError* self); +int QScxmlError_column(const QScxmlError* self); +struct miqt_string QScxmlError_description(const QScxmlError* self); +struct miqt_string QScxmlError_toString(const QScxmlError* self); + +void QScxmlError_delete(QScxmlError* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/scxml/gen_qscxmlevent.cpp b/qt6/scxml/gen_qscxmlevent.cpp new file mode 100644 index 000000000..17fd04574 --- /dev/null +++ b/qt6/scxml/gen_qscxmlevent.cpp @@ -0,0 +1,172 @@ +#include +#include +#include +#include +#include +#include +#include "gen_qscxmlevent.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +QScxmlEvent* QScxmlEvent_new() { + return new (std::nothrow) QScxmlEvent(); +} + +QScxmlEvent* QScxmlEvent_new2(QScxmlEvent* other) { + return new (std::nothrow) QScxmlEvent(*other); +} + +void QScxmlEvent_operatorAssign(QScxmlEvent* self, QScxmlEvent* other) { + self->operator=(*other); +} + +struct miqt_string QScxmlEvent_name(const QScxmlEvent* self) { + QString _ret = self->name(); + // 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 QScxmlEvent_setName(QScxmlEvent* self, struct miqt_string name) { + QString name_QString = QString::fromUtf8(name.data, name.len); + self->setName(name_QString); +} + +int QScxmlEvent_eventType(const QScxmlEvent* self) { + QScxmlEvent::EventType _ret = self->eventType(); + return static_cast(_ret); +} + +void QScxmlEvent_setEventType(QScxmlEvent* self, int* type) { + self->setEventType((const QScxmlEvent::EventType&)(*type)); +} + +struct miqt_string QScxmlEvent_scxmlType(const QScxmlEvent* self) { + QString _ret = self->scxmlType(); + // 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 QScxmlEvent_sendId(const QScxmlEvent* self) { + QString _ret = self->sendId(); + // 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 QScxmlEvent_setSendId(QScxmlEvent* self, struct miqt_string sendId) { + QString sendId_QString = QString::fromUtf8(sendId.data, sendId.len); + self->setSendId(sendId_QString); +} + +struct miqt_string QScxmlEvent_origin(const QScxmlEvent* self) { + QString _ret = self->origin(); + // 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 QScxmlEvent_setOrigin(QScxmlEvent* self, struct miqt_string origin) { + QString origin_QString = QString::fromUtf8(origin.data, origin.len); + self->setOrigin(origin_QString); +} + +struct miqt_string QScxmlEvent_originType(const QScxmlEvent* self) { + QString _ret = self->originType(); + // 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 QScxmlEvent_setOriginType(QScxmlEvent* self, struct miqt_string originType) { + QString originType_QString = QString::fromUtf8(originType.data, originType.len); + self->setOriginType(originType_QString); +} + +struct miqt_string QScxmlEvent_invokeId(const QScxmlEvent* self) { + QString _ret = self->invokeId(); + // 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 QScxmlEvent_setInvokeId(QScxmlEvent* self, struct miqt_string invokeId) { + QString invokeId_QString = QString::fromUtf8(invokeId.data, invokeId.len); + self->setInvokeId(invokeId_QString); +} + +int QScxmlEvent_delay(const QScxmlEvent* self) { + return self->delay(); +} + +void QScxmlEvent_setDelay(QScxmlEvent* self, int delayInMiliSecs) { + self->setDelay(static_cast(delayInMiliSecs)); +} + +void QScxmlEvent_clear(QScxmlEvent* self) { + self->clear(); +} + +QVariant* QScxmlEvent_data(const QScxmlEvent* self) { + return new QVariant(self->data()); +} + +void QScxmlEvent_setData(QScxmlEvent* self, QVariant* data) { + self->setData(*data); +} + +bool QScxmlEvent_isErrorEvent(const QScxmlEvent* self) { + return self->isErrorEvent(); +} + +struct miqt_string QScxmlEvent_errorMessage(const QScxmlEvent* self) { + QString _ret = self->errorMessage(); + // 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 QScxmlEvent_setErrorMessage(QScxmlEvent* self, struct miqt_string message) { + QString message_QString = QString::fromUtf8(message.data, message.len); + self->setErrorMessage(message_QString); +} + +void QScxmlEvent_delete(QScxmlEvent* self) { + delete self; +} + diff --git a/qt6/scxml/gen_qscxmlevent.go b/qt6/scxml/gen_qscxmlevent.go new file mode 100644 index 000000000..08c8dc982 --- /dev/null +++ b/qt6/scxml/gen_qscxmlevent.go @@ -0,0 +1,216 @@ +package scxml + +/* + +#include "gen_qscxmlevent.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "unsafe" +) + +type QScxmlEvent__EventType int + +const ( + QScxmlEvent__PlatformEvent QScxmlEvent__EventType = 0 + QScxmlEvent__InternalEvent QScxmlEvent__EventType = 1 + QScxmlEvent__ExternalEvent QScxmlEvent__EventType = 2 +) + +type QScxmlEvent struct { + h *C.QScxmlEvent +} + +func (this *QScxmlEvent) cPointer() *C.QScxmlEvent { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlEvent) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlEvent constructs the type using only CGO pointers. +func newQScxmlEvent(h *C.QScxmlEvent) *QScxmlEvent { + if h == nil { + return nil + } + + return &QScxmlEvent{h: h} +} + +// UnsafeNewQScxmlEvent constructs the type using only unsafe pointers. +func UnsafeNewQScxmlEvent(h unsafe.Pointer) *QScxmlEvent { + return newQScxmlEvent((*C.QScxmlEvent)(h)) +} + +// NewQScxmlEvent constructs a new QScxmlEvent object. +func NewQScxmlEvent() *QScxmlEvent { + + return newQScxmlEvent(C.QScxmlEvent_new()) +} + +// NewQScxmlEvent2 constructs a new QScxmlEvent object. +func NewQScxmlEvent2(other *QScxmlEvent) *QScxmlEvent { + + return newQScxmlEvent(C.QScxmlEvent_new2(other.cPointer())) +} + +func (this *QScxmlEvent) OperatorAssign(other *QScxmlEvent) { + C.QScxmlEvent_operatorAssign(this.h, other.cPointer()) +} + +func (this *QScxmlEvent) Name() string { + var _ms C.struct_miqt_string = C.QScxmlEvent_name(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlEvent) SetName(name string) { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + C.QScxmlEvent_setName(this.h, name_ms) +} + +func (this *QScxmlEvent) EventType() QScxmlEvent__EventType { + return (QScxmlEvent__EventType)(C.QScxmlEvent_eventType(this.h)) +} + +func (this *QScxmlEvent) SetEventType(typeVal *QScxmlEvent__EventType) { + C.QScxmlEvent_setEventType(this.h, (*C.int)(unsafe.Pointer(typeVal))) +} + +func (this *QScxmlEvent) ScxmlType() string { + var _ms C.struct_miqt_string = C.QScxmlEvent_scxmlType(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlEvent) SendId() string { + var _ms C.struct_miqt_string = C.QScxmlEvent_sendId(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlEvent) SetSendId(sendId string) { + sendId_ms := C.struct_miqt_string{} + sendId_ms.data = C.CString(sendId) + sendId_ms.len = C.size_t(len(sendId)) + defer C.free(unsafe.Pointer(sendId_ms.data)) + C.QScxmlEvent_setSendId(this.h, sendId_ms) +} + +func (this *QScxmlEvent) Origin() string { + var _ms C.struct_miqt_string = C.QScxmlEvent_origin(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlEvent) SetOrigin(origin string) { + origin_ms := C.struct_miqt_string{} + origin_ms.data = C.CString(origin) + origin_ms.len = C.size_t(len(origin)) + defer C.free(unsafe.Pointer(origin_ms.data)) + C.QScxmlEvent_setOrigin(this.h, origin_ms) +} + +func (this *QScxmlEvent) OriginType() string { + var _ms C.struct_miqt_string = C.QScxmlEvent_originType(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlEvent) SetOriginType(originType string) { + originType_ms := C.struct_miqt_string{} + originType_ms.data = C.CString(originType) + originType_ms.len = C.size_t(len(originType)) + defer C.free(unsafe.Pointer(originType_ms.data)) + C.QScxmlEvent_setOriginType(this.h, originType_ms) +} + +func (this *QScxmlEvent) InvokeId() string { + var _ms C.struct_miqt_string = C.QScxmlEvent_invokeId(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlEvent) SetInvokeId(invokeId string) { + invokeId_ms := C.struct_miqt_string{} + invokeId_ms.data = C.CString(invokeId) + invokeId_ms.len = C.size_t(len(invokeId)) + defer C.free(unsafe.Pointer(invokeId_ms.data)) + C.QScxmlEvent_setInvokeId(this.h, invokeId_ms) +} + +func (this *QScxmlEvent) Delay() int { + return (int)(C.QScxmlEvent_delay(this.h)) +} + +func (this *QScxmlEvent) SetDelay(delayInMiliSecs int) { + C.QScxmlEvent_setDelay(this.h, (C.int)(delayInMiliSecs)) +} + +func (this *QScxmlEvent) Clear() { + C.QScxmlEvent_clear(this.h) +} + +func (this *QScxmlEvent) Data() *qt6.QVariant { + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlEvent_data(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QScxmlEvent) SetData(data *qt6.QVariant) { + C.QScxmlEvent_setData(this.h, (*C.QVariant)(data.UnsafePointer())) +} + +func (this *QScxmlEvent) IsErrorEvent() bool { + return (bool)(C.QScxmlEvent_isErrorEvent(this.h)) +} + +func (this *QScxmlEvent) ErrorMessage() string { + var _ms C.struct_miqt_string = C.QScxmlEvent_errorMessage(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlEvent) SetErrorMessage(message string) { + message_ms := C.struct_miqt_string{} + message_ms.data = C.CString(message) + message_ms.len = C.size_t(len(message)) + defer C.free(unsafe.Pointer(message_ms.data)) + C.QScxmlEvent_setErrorMessage(this.h, message_ms) +} + +// Delete this object from C++ memory. +func (this *QScxmlEvent) Delete() { + C.QScxmlEvent_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 *QScxmlEvent) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlEvent) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/scxml/gen_qscxmlevent.h b/qt6/scxml/gen_qscxmlevent.h new file mode 100644 index 000000000..9570f2f05 --- /dev/null +++ b/qt6/scxml/gen_qscxmlevent.h @@ -0,0 +1,56 @@ +#pragma once +#ifndef MIQT_QT6_SCXML_GEN_QSCXMLEVENT_H +#define MIQT_QT6_SCXML_GEN_QSCXMLEVENT_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QScxmlEvent; +class QVariant; +#else +typedef struct QScxmlEvent QScxmlEvent; +typedef struct QVariant QVariant; +#endif + +QScxmlEvent* QScxmlEvent_new(); +QScxmlEvent* QScxmlEvent_new2(QScxmlEvent* other); +void QScxmlEvent_operatorAssign(QScxmlEvent* self, QScxmlEvent* other); +struct miqt_string QScxmlEvent_name(const QScxmlEvent* self); +void QScxmlEvent_setName(QScxmlEvent* self, struct miqt_string name); +int QScxmlEvent_eventType(const QScxmlEvent* self); +void QScxmlEvent_setEventType(QScxmlEvent* self, int* type); +struct miqt_string QScxmlEvent_scxmlType(const QScxmlEvent* self); +struct miqt_string QScxmlEvent_sendId(const QScxmlEvent* self); +void QScxmlEvent_setSendId(QScxmlEvent* self, struct miqt_string sendId); +struct miqt_string QScxmlEvent_origin(const QScxmlEvent* self); +void QScxmlEvent_setOrigin(QScxmlEvent* self, struct miqt_string origin); +struct miqt_string QScxmlEvent_originType(const QScxmlEvent* self); +void QScxmlEvent_setOriginType(QScxmlEvent* self, struct miqt_string originType); +struct miqt_string QScxmlEvent_invokeId(const QScxmlEvent* self); +void QScxmlEvent_setInvokeId(QScxmlEvent* self, struct miqt_string invokeId); +int QScxmlEvent_delay(const QScxmlEvent* self); +void QScxmlEvent_setDelay(QScxmlEvent* self, int delayInMiliSecs); +void QScxmlEvent_clear(QScxmlEvent* self); +QVariant* QScxmlEvent_data(const QScxmlEvent* self); +void QScxmlEvent_setData(QScxmlEvent* self, QVariant* data); +bool QScxmlEvent_isErrorEvent(const QScxmlEvent* self); +struct miqt_string QScxmlEvent_errorMessage(const QScxmlEvent* self); +void QScxmlEvent_setErrorMessage(QScxmlEvent* self, struct miqt_string message); + +void QScxmlEvent_delete(QScxmlEvent* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/scxml/gen_qscxmlexecutablecontent.cpp b/qt6/scxml/gen_qscxmlexecutablecontent.cpp new file mode 100644 index 000000000..386080b50 --- /dev/null +++ b/qt6/scxml/gen_qscxmlexecutablecontent.cpp @@ -0,0 +1,206 @@ +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__AssignmentInfo +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__EvaluatorInfo +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ForeachInfo +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__InvokeInfo +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ParameterInfo +#include +#include "gen_qscxmlexecutablecontent.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +int QScxmlExecutableContent__EvaluatorInfo_expr(const QScxmlExecutableContent__EvaluatorInfo* self) { + QScxmlExecutableContent::StringId expr_ret = self->expr; + return static_cast(expr_ret); +} + +void QScxmlExecutableContent__EvaluatorInfo_setExpr(QScxmlExecutableContent__EvaluatorInfo* self, int expr) { + self->expr = static_cast(expr); +} + +int QScxmlExecutableContent__EvaluatorInfo_context(const QScxmlExecutableContent__EvaluatorInfo* self) { + QScxmlExecutableContent::StringId context_ret = self->context; + return static_cast(context_ret); +} + +void QScxmlExecutableContent__EvaluatorInfo_setContext(QScxmlExecutableContent__EvaluatorInfo* self, int context) { + self->context = static_cast(context); +} + +void QScxmlExecutableContent__EvaluatorInfo_delete(QScxmlExecutableContent__EvaluatorInfo* self) { + delete self; +} + +int QScxmlExecutableContent__AssignmentInfo_dest(const QScxmlExecutableContent__AssignmentInfo* self) { + QScxmlExecutableContent::StringId dest_ret = self->dest; + return static_cast(dest_ret); +} + +void QScxmlExecutableContent__AssignmentInfo_setDest(QScxmlExecutableContent__AssignmentInfo* self, int dest) { + self->dest = static_cast(dest); +} + +int QScxmlExecutableContent__AssignmentInfo_expr(const QScxmlExecutableContent__AssignmentInfo* self) { + QScxmlExecutableContent::StringId expr_ret = self->expr; + return static_cast(expr_ret); +} + +void QScxmlExecutableContent__AssignmentInfo_setExpr(QScxmlExecutableContent__AssignmentInfo* self, int expr) { + self->expr = static_cast(expr); +} + +int QScxmlExecutableContent__AssignmentInfo_context(const QScxmlExecutableContent__AssignmentInfo* self) { + QScxmlExecutableContent::StringId context_ret = self->context; + return static_cast(context_ret); +} + +void QScxmlExecutableContent__AssignmentInfo_setContext(QScxmlExecutableContent__AssignmentInfo* self, int context) { + self->context = static_cast(context); +} + +void QScxmlExecutableContent__AssignmentInfo_delete(QScxmlExecutableContent__AssignmentInfo* self) { + delete self; +} + +int QScxmlExecutableContent__ForeachInfo_array(const QScxmlExecutableContent__ForeachInfo* self) { + QScxmlExecutableContent::StringId array_ret = self->array; + return static_cast(array_ret); +} + +void QScxmlExecutableContent__ForeachInfo_setArray(QScxmlExecutableContent__ForeachInfo* self, int array) { + self->array = static_cast(array); +} + +int QScxmlExecutableContent__ForeachInfo_item(const QScxmlExecutableContent__ForeachInfo* self) { + QScxmlExecutableContent::StringId item_ret = self->item; + return static_cast(item_ret); +} + +void QScxmlExecutableContent__ForeachInfo_setItem(QScxmlExecutableContent__ForeachInfo* self, int item) { + self->item = static_cast(item); +} + +int QScxmlExecutableContent__ForeachInfo_index(const QScxmlExecutableContent__ForeachInfo* self) { + QScxmlExecutableContent::StringId index_ret = self->index; + return static_cast(index_ret); +} + +void QScxmlExecutableContent__ForeachInfo_setIndex(QScxmlExecutableContent__ForeachInfo* self, int index) { + self->index = static_cast(index); +} + +int QScxmlExecutableContent__ForeachInfo_context(const QScxmlExecutableContent__ForeachInfo* self) { + QScxmlExecutableContent::StringId context_ret = self->context; + return static_cast(context_ret); +} + +void QScxmlExecutableContent__ForeachInfo_setContext(QScxmlExecutableContent__ForeachInfo* self, int context) { + self->context = static_cast(context); +} + +void QScxmlExecutableContent__ForeachInfo_delete(QScxmlExecutableContent__ForeachInfo* self) { + delete self; +} + +int QScxmlExecutableContent__ParameterInfo_name(const QScxmlExecutableContent__ParameterInfo* self) { + QScxmlExecutableContent::StringId name_ret = self->name; + return static_cast(name_ret); +} + +void QScxmlExecutableContent__ParameterInfo_setName(QScxmlExecutableContent__ParameterInfo* self, int name) { + self->name = static_cast(name); +} + +int QScxmlExecutableContent__ParameterInfo_expr(const QScxmlExecutableContent__ParameterInfo* self) { + QScxmlExecutableContent::EvaluatorId expr_ret = self->expr; + return static_cast(expr_ret); +} + +void QScxmlExecutableContent__ParameterInfo_setExpr(QScxmlExecutableContent__ParameterInfo* self, int expr) { + self->expr = static_cast(expr); +} + +int QScxmlExecutableContent__ParameterInfo_location(const QScxmlExecutableContent__ParameterInfo* self) { + QScxmlExecutableContent::StringId location_ret = self->location; + return static_cast(location_ret); +} + +void QScxmlExecutableContent__ParameterInfo_setLocation(QScxmlExecutableContent__ParameterInfo* self, int location) { + self->location = static_cast(location); +} + +void QScxmlExecutableContent__ParameterInfo_delete(QScxmlExecutableContent__ParameterInfo* self) { + delete self; +} + +int QScxmlExecutableContent__InvokeInfo_id(const QScxmlExecutableContent__InvokeInfo* self) { + QScxmlExecutableContent::StringId id_ret = self->id; + return static_cast(id_ret); +} + +void QScxmlExecutableContent__InvokeInfo_setId(QScxmlExecutableContent__InvokeInfo* self, int id) { + self->id = static_cast(id); +} + +int QScxmlExecutableContent__InvokeInfo_prefix(const QScxmlExecutableContent__InvokeInfo* self) { + QScxmlExecutableContent::StringId prefix_ret = self->prefix; + return static_cast(prefix_ret); +} + +void QScxmlExecutableContent__InvokeInfo_setPrefix(QScxmlExecutableContent__InvokeInfo* self, int prefix) { + self->prefix = static_cast(prefix); +} + +int QScxmlExecutableContent__InvokeInfo_location(const QScxmlExecutableContent__InvokeInfo* self) { + QScxmlExecutableContent::StringId location_ret = self->location; + return static_cast(location_ret); +} + +void QScxmlExecutableContent__InvokeInfo_setLocation(QScxmlExecutableContent__InvokeInfo* self, int location) { + self->location = static_cast(location); +} + +int QScxmlExecutableContent__InvokeInfo_context(const QScxmlExecutableContent__InvokeInfo* self) { + QScxmlExecutableContent::StringId context_ret = self->context; + return static_cast(context_ret); +} + +void QScxmlExecutableContent__InvokeInfo_setContext(QScxmlExecutableContent__InvokeInfo* self, int context) { + self->context = static_cast(context); +} + +int QScxmlExecutableContent__InvokeInfo_expr(const QScxmlExecutableContent__InvokeInfo* self) { + QScxmlExecutableContent::EvaluatorId expr_ret = self->expr; + return static_cast(expr_ret); +} + +void QScxmlExecutableContent__InvokeInfo_setExpr(QScxmlExecutableContent__InvokeInfo* self, int expr) { + self->expr = static_cast(expr); +} + +int QScxmlExecutableContent__InvokeInfo_finalize(const QScxmlExecutableContent__InvokeInfo* self) { + QScxmlExecutableContent::ContainerId finalize_ret = self->finalize; + return static_cast(finalize_ret); +} + +void QScxmlExecutableContent__InvokeInfo_setFinalize(QScxmlExecutableContent__InvokeInfo* self, int finalize) { + self->finalize = static_cast(finalize); +} + +bool QScxmlExecutableContent__InvokeInfo_autoforward(const QScxmlExecutableContent__InvokeInfo* self) { + return self->autoforward; +} + +void QScxmlExecutableContent__InvokeInfo_setAutoforward(QScxmlExecutableContent__InvokeInfo* self, bool autoforward) { + self->autoforward = autoforward; +} + +void QScxmlExecutableContent__InvokeInfo_delete(QScxmlExecutableContent__InvokeInfo* self) { + delete self; +} + diff --git a/qt6/scxml/gen_qscxmlexecutablecontent.go b/qt6/scxml/gen_qscxmlexecutablecontent.go new file mode 100644 index 000000000..72b02f688 --- /dev/null +++ b/qt6/scxml/gen_qscxmlexecutablecontent.go @@ -0,0 +1,405 @@ +package scxml + +/* + +#include "gen_qscxmlexecutablecontent.h" +#include + +*/ +import "C" + +import ( + "runtime" + "unsafe" +) + +type QScxmlExecutableContent__ int + +const ( + QScxmlExecutableContent__NoContainer QScxmlExecutableContent__ = -1 + QScxmlExecutableContent__NoString QScxmlExecutableContent__ = -1 + QScxmlExecutableContent__NoInstruction QScxmlExecutableContent__ = -1 + QScxmlExecutableContent__NoEvaluator QScxmlExecutableContent__ = -1 +) + +type QScxmlExecutableContent__EvaluatorInfo struct { + h *C.QScxmlExecutableContent__EvaluatorInfo +} + +func (this *QScxmlExecutableContent__EvaluatorInfo) cPointer() *C.QScxmlExecutableContent__EvaluatorInfo { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlExecutableContent__EvaluatorInfo) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlExecutableContent__EvaluatorInfo constructs the type using only CGO pointers. +func newQScxmlExecutableContent__EvaluatorInfo(h *C.QScxmlExecutableContent__EvaluatorInfo) *QScxmlExecutableContent__EvaluatorInfo { + if h == nil { + return nil + } + + return &QScxmlExecutableContent__EvaluatorInfo{h: h} +} + +// UnsafeNewQScxmlExecutableContent__EvaluatorInfo constructs the type using only unsafe pointers. +func UnsafeNewQScxmlExecutableContent__EvaluatorInfo(h unsafe.Pointer) *QScxmlExecutableContent__EvaluatorInfo { + return newQScxmlExecutableContent__EvaluatorInfo((*C.QScxmlExecutableContent__EvaluatorInfo)(h)) +} + +func (this *QScxmlExecutableContent__EvaluatorInfo) Expr() int { + return (int)(C.QScxmlExecutableContent__EvaluatorInfo_expr(this.h)) +} + +func (this *QScxmlExecutableContent__EvaluatorInfo) SetExpr(expr int) { + C.QScxmlExecutableContent__EvaluatorInfo_setExpr(this.h, (C.int)(expr)) +} + +func (this *QScxmlExecutableContent__EvaluatorInfo) Context() int { + return (int)(C.QScxmlExecutableContent__EvaluatorInfo_context(this.h)) +} + +func (this *QScxmlExecutableContent__EvaluatorInfo) SetContext(context int) { + C.QScxmlExecutableContent__EvaluatorInfo_setContext(this.h, (C.int)(context)) +} + +// Delete this object from C++ memory. +func (this *QScxmlExecutableContent__EvaluatorInfo) Delete() { + C.QScxmlExecutableContent__EvaluatorInfo_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 *QScxmlExecutableContent__EvaluatorInfo) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlExecutableContent__EvaluatorInfo) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type QScxmlExecutableContent__AssignmentInfo struct { + h *C.QScxmlExecutableContent__AssignmentInfo +} + +func (this *QScxmlExecutableContent__AssignmentInfo) cPointer() *C.QScxmlExecutableContent__AssignmentInfo { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlExecutableContent__AssignmentInfo) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlExecutableContent__AssignmentInfo constructs the type using only CGO pointers. +func newQScxmlExecutableContent__AssignmentInfo(h *C.QScxmlExecutableContent__AssignmentInfo) *QScxmlExecutableContent__AssignmentInfo { + if h == nil { + return nil + } + + return &QScxmlExecutableContent__AssignmentInfo{h: h} +} + +// UnsafeNewQScxmlExecutableContent__AssignmentInfo constructs the type using only unsafe pointers. +func UnsafeNewQScxmlExecutableContent__AssignmentInfo(h unsafe.Pointer) *QScxmlExecutableContent__AssignmentInfo { + return newQScxmlExecutableContent__AssignmentInfo((*C.QScxmlExecutableContent__AssignmentInfo)(h)) +} + +func (this *QScxmlExecutableContent__AssignmentInfo) Dest() int { + return (int)(C.QScxmlExecutableContent__AssignmentInfo_dest(this.h)) +} + +func (this *QScxmlExecutableContent__AssignmentInfo) SetDest(dest int) { + C.QScxmlExecutableContent__AssignmentInfo_setDest(this.h, (C.int)(dest)) +} + +func (this *QScxmlExecutableContent__AssignmentInfo) Expr() int { + return (int)(C.QScxmlExecutableContent__AssignmentInfo_expr(this.h)) +} + +func (this *QScxmlExecutableContent__AssignmentInfo) SetExpr(expr int) { + C.QScxmlExecutableContent__AssignmentInfo_setExpr(this.h, (C.int)(expr)) +} + +func (this *QScxmlExecutableContent__AssignmentInfo) Context() int { + return (int)(C.QScxmlExecutableContent__AssignmentInfo_context(this.h)) +} + +func (this *QScxmlExecutableContent__AssignmentInfo) SetContext(context int) { + C.QScxmlExecutableContent__AssignmentInfo_setContext(this.h, (C.int)(context)) +} + +// Delete this object from C++ memory. +func (this *QScxmlExecutableContent__AssignmentInfo) Delete() { + C.QScxmlExecutableContent__AssignmentInfo_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 *QScxmlExecutableContent__AssignmentInfo) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlExecutableContent__AssignmentInfo) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type QScxmlExecutableContent__ForeachInfo struct { + h *C.QScxmlExecutableContent__ForeachInfo +} + +func (this *QScxmlExecutableContent__ForeachInfo) cPointer() *C.QScxmlExecutableContent__ForeachInfo { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlExecutableContent__ForeachInfo) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlExecutableContent__ForeachInfo constructs the type using only CGO pointers. +func newQScxmlExecutableContent__ForeachInfo(h *C.QScxmlExecutableContent__ForeachInfo) *QScxmlExecutableContent__ForeachInfo { + if h == nil { + return nil + } + + return &QScxmlExecutableContent__ForeachInfo{h: h} +} + +// UnsafeNewQScxmlExecutableContent__ForeachInfo constructs the type using only unsafe pointers. +func UnsafeNewQScxmlExecutableContent__ForeachInfo(h unsafe.Pointer) *QScxmlExecutableContent__ForeachInfo { + return newQScxmlExecutableContent__ForeachInfo((*C.QScxmlExecutableContent__ForeachInfo)(h)) +} + +func (this *QScxmlExecutableContent__ForeachInfo) Array() int { + return (int)(C.QScxmlExecutableContent__ForeachInfo_array(this.h)) +} + +func (this *QScxmlExecutableContent__ForeachInfo) SetArray(array int) { + C.QScxmlExecutableContent__ForeachInfo_setArray(this.h, (C.int)(array)) +} + +func (this *QScxmlExecutableContent__ForeachInfo) Item() int { + return (int)(C.QScxmlExecutableContent__ForeachInfo_item(this.h)) +} + +func (this *QScxmlExecutableContent__ForeachInfo) SetItem(item int) { + C.QScxmlExecutableContent__ForeachInfo_setItem(this.h, (C.int)(item)) +} + +func (this *QScxmlExecutableContent__ForeachInfo) Index() int { + return (int)(C.QScxmlExecutableContent__ForeachInfo_index(this.h)) +} + +func (this *QScxmlExecutableContent__ForeachInfo) SetIndex(index int) { + C.QScxmlExecutableContent__ForeachInfo_setIndex(this.h, (C.int)(index)) +} + +func (this *QScxmlExecutableContent__ForeachInfo) Context() int { + return (int)(C.QScxmlExecutableContent__ForeachInfo_context(this.h)) +} + +func (this *QScxmlExecutableContent__ForeachInfo) SetContext(context int) { + C.QScxmlExecutableContent__ForeachInfo_setContext(this.h, (C.int)(context)) +} + +// Delete this object from C++ memory. +func (this *QScxmlExecutableContent__ForeachInfo) Delete() { + C.QScxmlExecutableContent__ForeachInfo_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 *QScxmlExecutableContent__ForeachInfo) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlExecutableContent__ForeachInfo) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type QScxmlExecutableContent__ParameterInfo struct { + h *C.QScxmlExecutableContent__ParameterInfo +} + +func (this *QScxmlExecutableContent__ParameterInfo) cPointer() *C.QScxmlExecutableContent__ParameterInfo { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlExecutableContent__ParameterInfo) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlExecutableContent__ParameterInfo constructs the type using only CGO pointers. +func newQScxmlExecutableContent__ParameterInfo(h *C.QScxmlExecutableContent__ParameterInfo) *QScxmlExecutableContent__ParameterInfo { + if h == nil { + return nil + } + + return &QScxmlExecutableContent__ParameterInfo{h: h} +} + +// UnsafeNewQScxmlExecutableContent__ParameterInfo constructs the type using only unsafe pointers. +func UnsafeNewQScxmlExecutableContent__ParameterInfo(h unsafe.Pointer) *QScxmlExecutableContent__ParameterInfo { + return newQScxmlExecutableContent__ParameterInfo((*C.QScxmlExecutableContent__ParameterInfo)(h)) +} + +func (this *QScxmlExecutableContent__ParameterInfo) Name() int { + return (int)(C.QScxmlExecutableContent__ParameterInfo_name(this.h)) +} + +func (this *QScxmlExecutableContent__ParameterInfo) SetName(name int) { + C.QScxmlExecutableContent__ParameterInfo_setName(this.h, (C.int)(name)) +} + +func (this *QScxmlExecutableContent__ParameterInfo) Expr() int { + return (int)(C.QScxmlExecutableContent__ParameterInfo_expr(this.h)) +} + +func (this *QScxmlExecutableContent__ParameterInfo) SetExpr(expr int) { + C.QScxmlExecutableContent__ParameterInfo_setExpr(this.h, (C.int)(expr)) +} + +func (this *QScxmlExecutableContent__ParameterInfo) Location() int { + return (int)(C.QScxmlExecutableContent__ParameterInfo_location(this.h)) +} + +func (this *QScxmlExecutableContent__ParameterInfo) SetLocation(location int) { + C.QScxmlExecutableContent__ParameterInfo_setLocation(this.h, (C.int)(location)) +} + +// Delete this object from C++ memory. +func (this *QScxmlExecutableContent__ParameterInfo) Delete() { + C.QScxmlExecutableContent__ParameterInfo_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 *QScxmlExecutableContent__ParameterInfo) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlExecutableContent__ParameterInfo) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type QScxmlExecutableContent__InvokeInfo struct { + h *C.QScxmlExecutableContent__InvokeInfo +} + +func (this *QScxmlExecutableContent__InvokeInfo) cPointer() *C.QScxmlExecutableContent__InvokeInfo { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlExecutableContent__InvokeInfo) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlExecutableContent__InvokeInfo constructs the type using only CGO pointers. +func newQScxmlExecutableContent__InvokeInfo(h *C.QScxmlExecutableContent__InvokeInfo) *QScxmlExecutableContent__InvokeInfo { + if h == nil { + return nil + } + + return &QScxmlExecutableContent__InvokeInfo{h: h} +} + +// UnsafeNewQScxmlExecutableContent__InvokeInfo constructs the type using only unsafe pointers. +func UnsafeNewQScxmlExecutableContent__InvokeInfo(h unsafe.Pointer) *QScxmlExecutableContent__InvokeInfo { + return newQScxmlExecutableContent__InvokeInfo((*C.QScxmlExecutableContent__InvokeInfo)(h)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) Id() int { + return (int)(C.QScxmlExecutableContent__InvokeInfo_id(this.h)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) SetId(id int) { + C.QScxmlExecutableContent__InvokeInfo_setId(this.h, (C.int)(id)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) Prefix() int { + return (int)(C.QScxmlExecutableContent__InvokeInfo_prefix(this.h)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) SetPrefix(prefix int) { + C.QScxmlExecutableContent__InvokeInfo_setPrefix(this.h, (C.int)(prefix)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) Location() int { + return (int)(C.QScxmlExecutableContent__InvokeInfo_location(this.h)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) SetLocation(location int) { + C.QScxmlExecutableContent__InvokeInfo_setLocation(this.h, (C.int)(location)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) Context() int { + return (int)(C.QScxmlExecutableContent__InvokeInfo_context(this.h)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) SetContext(context int) { + C.QScxmlExecutableContent__InvokeInfo_setContext(this.h, (C.int)(context)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) Expr() int { + return (int)(C.QScxmlExecutableContent__InvokeInfo_expr(this.h)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) SetExpr(expr int) { + C.QScxmlExecutableContent__InvokeInfo_setExpr(this.h, (C.int)(expr)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) Finalize() int { + return (int)(C.QScxmlExecutableContent__InvokeInfo_finalize(this.h)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) SetFinalize(finalize int) { + C.QScxmlExecutableContent__InvokeInfo_setFinalize(this.h, (C.int)(finalize)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) Autoforward() bool { + return (bool)(C.QScxmlExecutableContent__InvokeInfo_autoforward(this.h)) +} + +func (this *QScxmlExecutableContent__InvokeInfo) SetAutoforward(autoforward bool) { + C.QScxmlExecutableContent__InvokeInfo_setAutoforward(this.h, (C.bool)(autoforward)) +} + +// Delete this object from C++ memory. +func (this *QScxmlExecutableContent__InvokeInfo) Delete() { + C.QScxmlExecutableContent__InvokeInfo_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 *QScxmlExecutableContent__InvokeInfo) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlExecutableContent__InvokeInfo) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/scxml/gen_qscxmlexecutablecontent.h b/qt6/scxml/gen_qscxmlexecutablecontent.h new file mode 100644 index 000000000..03db72373 --- /dev/null +++ b/qt6/scxml/gen_qscxmlexecutablecontent.h @@ -0,0 +1,108 @@ +#pragma once +#ifndef MIQT_QT6_SCXML_GEN_QSCXMLEXECUTABLECONTENT_H +#define MIQT_QT6_SCXML_GEN_QSCXMLEXECUTABLECONTENT_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__AssignmentInfo) +typedef QScxmlExecutableContent::AssignmentInfo QScxmlExecutableContent__AssignmentInfo; +#else +class QScxmlExecutableContent__AssignmentInfo; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__EvaluatorInfo) +typedef QScxmlExecutableContent::EvaluatorInfo QScxmlExecutableContent__EvaluatorInfo; +#else +class QScxmlExecutableContent__EvaluatorInfo; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ForeachInfo) +typedef QScxmlExecutableContent::ForeachInfo QScxmlExecutableContent__ForeachInfo; +#else +class QScxmlExecutableContent__ForeachInfo; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__InvokeInfo) +typedef QScxmlExecutableContent::InvokeInfo QScxmlExecutableContent__InvokeInfo; +#else +class QScxmlExecutableContent__InvokeInfo; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ParameterInfo) +typedef QScxmlExecutableContent::ParameterInfo QScxmlExecutableContent__ParameterInfo; +#else +class QScxmlExecutableContent__ParameterInfo; +#endif +#else +typedef struct QScxmlExecutableContent__AssignmentInfo QScxmlExecutableContent__AssignmentInfo; +typedef struct QScxmlExecutableContent__EvaluatorInfo QScxmlExecutableContent__EvaluatorInfo; +typedef struct QScxmlExecutableContent__ForeachInfo QScxmlExecutableContent__ForeachInfo; +typedef struct QScxmlExecutableContent__InvokeInfo QScxmlExecutableContent__InvokeInfo; +typedef struct QScxmlExecutableContent__ParameterInfo QScxmlExecutableContent__ParameterInfo; +#endif + +int QScxmlExecutableContent__EvaluatorInfo_expr(const QScxmlExecutableContent__EvaluatorInfo* self); +void QScxmlExecutableContent__EvaluatorInfo_setExpr(QScxmlExecutableContent__EvaluatorInfo* self, int expr); +int QScxmlExecutableContent__EvaluatorInfo_context(const QScxmlExecutableContent__EvaluatorInfo* self); +void QScxmlExecutableContent__EvaluatorInfo_setContext(QScxmlExecutableContent__EvaluatorInfo* self, int context); + +void QScxmlExecutableContent__EvaluatorInfo_delete(QScxmlExecutableContent__EvaluatorInfo* self); + +int QScxmlExecutableContent__AssignmentInfo_dest(const QScxmlExecutableContent__AssignmentInfo* self); +void QScxmlExecutableContent__AssignmentInfo_setDest(QScxmlExecutableContent__AssignmentInfo* self, int dest); +int QScxmlExecutableContent__AssignmentInfo_expr(const QScxmlExecutableContent__AssignmentInfo* self); +void QScxmlExecutableContent__AssignmentInfo_setExpr(QScxmlExecutableContent__AssignmentInfo* self, int expr); +int QScxmlExecutableContent__AssignmentInfo_context(const QScxmlExecutableContent__AssignmentInfo* self); +void QScxmlExecutableContent__AssignmentInfo_setContext(QScxmlExecutableContent__AssignmentInfo* self, int context); + +void QScxmlExecutableContent__AssignmentInfo_delete(QScxmlExecutableContent__AssignmentInfo* self); + +int QScxmlExecutableContent__ForeachInfo_array(const QScxmlExecutableContent__ForeachInfo* self); +void QScxmlExecutableContent__ForeachInfo_setArray(QScxmlExecutableContent__ForeachInfo* self, int array); +int QScxmlExecutableContent__ForeachInfo_item(const QScxmlExecutableContent__ForeachInfo* self); +void QScxmlExecutableContent__ForeachInfo_setItem(QScxmlExecutableContent__ForeachInfo* self, int item); +int QScxmlExecutableContent__ForeachInfo_index(const QScxmlExecutableContent__ForeachInfo* self); +void QScxmlExecutableContent__ForeachInfo_setIndex(QScxmlExecutableContent__ForeachInfo* self, int index); +int QScxmlExecutableContent__ForeachInfo_context(const QScxmlExecutableContent__ForeachInfo* self); +void QScxmlExecutableContent__ForeachInfo_setContext(QScxmlExecutableContent__ForeachInfo* self, int context); + +void QScxmlExecutableContent__ForeachInfo_delete(QScxmlExecutableContent__ForeachInfo* self); + +int QScxmlExecutableContent__ParameterInfo_name(const QScxmlExecutableContent__ParameterInfo* self); +void QScxmlExecutableContent__ParameterInfo_setName(QScxmlExecutableContent__ParameterInfo* self, int name); +int QScxmlExecutableContent__ParameterInfo_expr(const QScxmlExecutableContent__ParameterInfo* self); +void QScxmlExecutableContent__ParameterInfo_setExpr(QScxmlExecutableContent__ParameterInfo* self, int expr); +int QScxmlExecutableContent__ParameterInfo_location(const QScxmlExecutableContent__ParameterInfo* self); +void QScxmlExecutableContent__ParameterInfo_setLocation(QScxmlExecutableContent__ParameterInfo* self, int location); + +void QScxmlExecutableContent__ParameterInfo_delete(QScxmlExecutableContent__ParameterInfo* self); + +int QScxmlExecutableContent__InvokeInfo_id(const QScxmlExecutableContent__InvokeInfo* self); +void QScxmlExecutableContent__InvokeInfo_setId(QScxmlExecutableContent__InvokeInfo* self, int id); +int QScxmlExecutableContent__InvokeInfo_prefix(const QScxmlExecutableContent__InvokeInfo* self); +void QScxmlExecutableContent__InvokeInfo_setPrefix(QScxmlExecutableContent__InvokeInfo* self, int prefix); +int QScxmlExecutableContent__InvokeInfo_location(const QScxmlExecutableContent__InvokeInfo* self); +void QScxmlExecutableContent__InvokeInfo_setLocation(QScxmlExecutableContent__InvokeInfo* self, int location); +int QScxmlExecutableContent__InvokeInfo_context(const QScxmlExecutableContent__InvokeInfo* self); +void QScxmlExecutableContent__InvokeInfo_setContext(QScxmlExecutableContent__InvokeInfo* self, int context); +int QScxmlExecutableContent__InvokeInfo_expr(const QScxmlExecutableContent__InvokeInfo* self); +void QScxmlExecutableContent__InvokeInfo_setExpr(QScxmlExecutableContent__InvokeInfo* self, int expr); +int QScxmlExecutableContent__InvokeInfo_finalize(const QScxmlExecutableContent__InvokeInfo* self); +void QScxmlExecutableContent__InvokeInfo_setFinalize(QScxmlExecutableContent__InvokeInfo* self, int finalize); +bool QScxmlExecutableContent__InvokeInfo_autoforward(const QScxmlExecutableContent__InvokeInfo* self); +void QScxmlExecutableContent__InvokeInfo_setAutoforward(QScxmlExecutableContent__InvokeInfo* self, bool autoforward); + +void QScxmlExecutableContent__InvokeInfo_delete(QScxmlExecutableContent__InvokeInfo* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/scxml/gen_qscxmlinvokableservice.cpp b/qt6/scxml/gen_qscxmlinvokableservice.cpp new file mode 100644 index 000000000..6afbd27af --- /dev/null +++ b/qt6/scxml/gen_qscxmlinvokableservice.cpp @@ -0,0 +1,1732 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__InvokeInfo +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ParameterInfo +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qscxmlinvokableservice.h" + +#ifdef __cplusplus +extern "C" { +#endif + +bool miqt_exec_callback_QScxmlInvokableService_start(QScxmlInvokableService*, intptr_t); +struct miqt_string miqt_exec_callback_QScxmlInvokableService_id(const QScxmlInvokableService*, intptr_t); +struct miqt_string miqt_exec_callback_QScxmlInvokableService_name(const QScxmlInvokableService*, intptr_t); +void miqt_exec_callback_QScxmlInvokableService_postEvent(QScxmlInvokableService*, intptr_t, QScxmlEvent*); +bool miqt_exec_callback_QScxmlInvokableService_event(QScxmlInvokableService*, intptr_t, QEvent*); +bool miqt_exec_callback_QScxmlInvokableService_eventFilter(QScxmlInvokableService*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QScxmlInvokableService_timerEvent(QScxmlInvokableService*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QScxmlInvokableService_childEvent(QScxmlInvokableService*, intptr_t, QChildEvent*); +void miqt_exec_callback_QScxmlInvokableService_customEvent(QScxmlInvokableService*, intptr_t, QEvent*); +void miqt_exec_callback_QScxmlInvokableService_connectNotify(QScxmlInvokableService*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QScxmlInvokableService_disconnectNotify(QScxmlInvokableService*, intptr_t, QMetaMethod*); +QScxmlInvokableService* miqt_exec_callback_QScxmlInvokableServiceFactory_invoke(QScxmlInvokableServiceFactory*, intptr_t, QScxmlStateMachine*); +bool miqt_exec_callback_QScxmlInvokableServiceFactory_event(QScxmlInvokableServiceFactory*, intptr_t, QEvent*); +bool miqt_exec_callback_QScxmlInvokableServiceFactory_eventFilter(QScxmlInvokableServiceFactory*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QScxmlInvokableServiceFactory_timerEvent(QScxmlInvokableServiceFactory*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QScxmlInvokableServiceFactory_childEvent(QScxmlInvokableServiceFactory*, intptr_t, QChildEvent*); +void miqt_exec_callback_QScxmlInvokableServiceFactory_customEvent(QScxmlInvokableServiceFactory*, intptr_t, QEvent*); +void miqt_exec_callback_QScxmlInvokableServiceFactory_connectNotify(QScxmlInvokableServiceFactory*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QScxmlInvokableServiceFactory_disconnectNotify(QScxmlInvokableServiceFactory*, intptr_t, QMetaMethod*); +QScxmlInvokableService* miqt_exec_callback_QScxmlStaticScxmlServiceFactory_invoke(QScxmlStaticScxmlServiceFactory*, intptr_t, QScxmlStateMachine*); +bool miqt_exec_callback_QScxmlStaticScxmlServiceFactory_event(QScxmlStaticScxmlServiceFactory*, intptr_t, QEvent*); +bool miqt_exec_callback_QScxmlStaticScxmlServiceFactory_eventFilter(QScxmlStaticScxmlServiceFactory*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QScxmlStaticScxmlServiceFactory_timerEvent(QScxmlStaticScxmlServiceFactory*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QScxmlStaticScxmlServiceFactory_childEvent(QScxmlStaticScxmlServiceFactory*, intptr_t, QChildEvent*); +void miqt_exec_callback_QScxmlStaticScxmlServiceFactory_customEvent(QScxmlStaticScxmlServiceFactory*, intptr_t, QEvent*); +void miqt_exec_callback_QScxmlStaticScxmlServiceFactory_connectNotify(QScxmlStaticScxmlServiceFactory*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QScxmlStaticScxmlServiceFactory_disconnectNotify(QScxmlStaticScxmlServiceFactory*, intptr_t, QMetaMethod*); +QScxmlInvokableService* miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_invoke(QScxmlDynamicScxmlServiceFactory*, intptr_t, QScxmlStateMachine*); +bool miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_event(QScxmlDynamicScxmlServiceFactory*, intptr_t, QEvent*); +bool miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_eventFilter(QScxmlDynamicScxmlServiceFactory*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_timerEvent(QScxmlDynamicScxmlServiceFactory*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_childEvent(QScxmlDynamicScxmlServiceFactory*, intptr_t, QChildEvent*); +void miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_customEvent(QScxmlDynamicScxmlServiceFactory*, intptr_t, QEvent*); +void miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_connectNotify(QScxmlDynamicScxmlServiceFactory*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_disconnectNotify(QScxmlDynamicScxmlServiceFactory*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQScxmlInvokableService final : public QScxmlInvokableService { +public: + + MiqtVirtualQScxmlInvokableService(QScxmlStateMachine* parentStateMachine, QScxmlInvokableServiceFactory* parent): QScxmlInvokableService(parentStateMachine, parent) {} + + virtual ~MiqtVirtualQScxmlInvokableService() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__start = 0; + + // Subclass to allow providing a Go implementation + virtual bool start() override { + if (handle__start == 0) { + return false; // Pure virtual, there is no base we can call + } + + bool callback_return_value = miqt_exec_callback_QScxmlInvokableService_start(this, handle__start); + return callback_return_value; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__id = 0; + + // Subclass to allow providing a Go implementation + virtual QString id() const override { + if (handle__id == 0) { + return QString(); // Pure virtual, there is no base we can call + } + + struct miqt_string callback_return_value = miqt_exec_callback_QScxmlInvokableService_id(this, handle__id); + QString callback_return_value_QString = QString::fromUtf8(callback_return_value.data, callback_return_value.len); + return callback_return_value_QString; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__name = 0; + + // Subclass to allow providing a Go implementation + virtual QString name() const override { + if (handle__name == 0) { + return QString(); // Pure virtual, there is no base we can call + } + + struct miqt_string callback_return_value = miqt_exec_callback_QScxmlInvokableService_name(this, handle__name); + QString callback_return_value_QString = QString::fromUtf8(callback_return_value.data, callback_return_value.len); + return callback_return_value_QString; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__postEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void postEvent(QScxmlEvent* event) override { + if (handle__postEvent == 0) { + return; // Pure virtual, there is no base we can call + } + + QScxmlEvent* sigval1 = event; + miqt_exec_callback_QScxmlInvokableService_postEvent(this, handle__postEvent, sigval1); + + } + + // 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 QScxmlInvokableService::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QScxmlInvokableService_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QScxmlInvokableService_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 QScxmlInvokableService::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QScxmlInvokableService_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QScxmlInvokableService_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) { + QScxmlInvokableService::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QScxmlInvokableService_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QScxmlInvokableService_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) { + QScxmlInvokableService::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QScxmlInvokableService_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QScxmlInvokableService_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) { + QScxmlInvokableService::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QScxmlInvokableService_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QScxmlInvokableService_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) { + QScxmlInvokableService::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlInvokableService_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QScxmlInvokableService_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) { + QScxmlInvokableService::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlInvokableService_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QScxmlInvokableService_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QScxmlInvokableService_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlInvokableService_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlInvokableService_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QScxmlInvokableService_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QScxmlInvokableService* QScxmlInvokableService_new(QScxmlStateMachine* parentStateMachine, QScxmlInvokableServiceFactory* parent) { + return new (std::nothrow) MiqtVirtualQScxmlInvokableService(parentStateMachine, parent); +} + +void QScxmlInvokableService_virtbase(QScxmlInvokableService* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QScxmlInvokableService_metaObject(const QScxmlInvokableService* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QScxmlInvokableService_metacast(QScxmlInvokableService* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QScxmlInvokableService_tr(const char* s) { + QString _ret = QScxmlInvokableService::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; +} + +QScxmlStateMachine* QScxmlInvokableService_parentStateMachine(const QScxmlInvokableService* self) { + return self->parentStateMachine(); +} + +bool QScxmlInvokableService_start(QScxmlInvokableService* self) { + return self->start(); +} + +struct miqt_string QScxmlInvokableService_id(const QScxmlInvokableService* self) { + QString _ret = self->id(); + // 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 QScxmlInvokableService_name(const QScxmlInvokableService* self) { + QString _ret = self->name(); + // 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 QScxmlInvokableService_postEvent(QScxmlInvokableService* self, QScxmlEvent* event) { + self->postEvent(event); +} + +struct miqt_string QScxmlInvokableService_tr2(const char* s, const char* c) { + QString _ret = QScxmlInvokableService::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 QScxmlInvokableService_tr3(const char* s, const char* c, int n) { + QString _ret = QScxmlInvokableService::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 QScxmlInvokableService_override_virtual_start(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__start = slot; + return true; +} + +bool QScxmlInvokableService_override_virtual_id(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__id = slot; + return true; +} + +bool QScxmlInvokableService_override_virtual_name(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__name = slot; + return true; +} + +bool QScxmlInvokableService_override_virtual_postEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__postEvent = slot; + return true; +} + +bool QScxmlInvokableService_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QScxmlInvokableService_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QScxmlInvokableService::event(event); +} + +bool QScxmlInvokableService_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QScxmlInvokableService_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QScxmlInvokableService::eventFilter(watched, event); +} + +bool QScxmlInvokableService_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QScxmlInvokableService_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QScxmlInvokableService::timerEvent(event); +} + +bool QScxmlInvokableService_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QScxmlInvokableService_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QScxmlInvokableService::childEvent(event); +} + +bool QScxmlInvokableService_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QScxmlInvokableService_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QScxmlInvokableService::customEvent(event); +} + +bool QScxmlInvokableService_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QScxmlInvokableService_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlInvokableService::connectNotify(*signal); +} + +bool QScxmlInvokableService_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QScxmlInvokableService_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlInvokableService::disconnectNotify(*signal); +} + +QObject* QScxmlInvokableService_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QScxmlInvokableService_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QScxmlInvokableService_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QScxmlInvokableService_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QScxmlInvokableService_delete(QScxmlInvokableService* self) { + delete self; +} + +class MiqtVirtualQScxmlInvokableServiceFactory final : public QScxmlInvokableServiceFactory { +public: + + MiqtVirtualQScxmlInvokableServiceFactory(const QScxmlExecutableContent::InvokeInfo& invokeInfo, const QList& names, const QList& parameters): QScxmlInvokableServiceFactory(invokeInfo, names, parameters) {} + MiqtVirtualQScxmlInvokableServiceFactory(const QScxmlExecutableContent::InvokeInfo& invokeInfo, const QList& names, const QList& parameters, QObject* parent): QScxmlInvokableServiceFactory(invokeInfo, names, parameters, parent) {} + + virtual ~MiqtVirtualQScxmlInvokableServiceFactory() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__invoke = 0; + + // Subclass to allow providing a Go implementation + virtual QScxmlInvokableService* invoke(QScxmlStateMachine* parentStateMachine) override { + if (handle__invoke == 0) { + return nullptr; // Pure virtual, there is no base we can call + } + + QScxmlStateMachine* sigval1 = parentStateMachine; + QScxmlInvokableService* callback_return_value = miqt_exec_callback_QScxmlInvokableServiceFactory_invoke(this, handle__invoke, sigval1); + return callback_return_value; + } + + // 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 QScxmlInvokableServiceFactory::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QScxmlInvokableServiceFactory_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QScxmlInvokableServiceFactory_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 QScxmlInvokableServiceFactory::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QScxmlInvokableServiceFactory_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QScxmlInvokableServiceFactory_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) { + QScxmlInvokableServiceFactory::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QScxmlInvokableServiceFactory_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QScxmlInvokableServiceFactory_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) { + QScxmlInvokableServiceFactory::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QScxmlInvokableServiceFactory_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QScxmlInvokableServiceFactory_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) { + QScxmlInvokableServiceFactory::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QScxmlInvokableServiceFactory_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QScxmlInvokableServiceFactory_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) { + QScxmlInvokableServiceFactory::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlInvokableServiceFactory_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QScxmlInvokableServiceFactory_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) { + QScxmlInvokableServiceFactory::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlInvokableServiceFactory_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QScxmlInvokableServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QScxmlInvokableServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlInvokableServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlInvokableServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QScxmlInvokableServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QScxmlInvokableServiceFactory* QScxmlInvokableServiceFactory_new(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters) { + QList names_QList; + names_QList.reserve(names.len); + int* names_arr = static_cast(names.data); + for(size_t i = 0; i < names.len; ++i) { + names_QList.push_back(static_cast(names_arr[i])); + } + QList parameters_QList; + parameters_QList.reserve(parameters.len); + QScxmlExecutableContent__ParameterInfo** parameters_arr = static_cast(parameters.data); + for(size_t i = 0; i < parameters.len; ++i) { + parameters_QList.push_back(*(parameters_arr[i])); + } + return new (std::nothrow) MiqtVirtualQScxmlInvokableServiceFactory(*invokeInfo, names_QList, parameters_QList); +} + +QScxmlInvokableServiceFactory* QScxmlInvokableServiceFactory_new2(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters, QObject* parent) { + QList names_QList; + names_QList.reserve(names.len); + int* names_arr = static_cast(names.data); + for(size_t i = 0; i < names.len; ++i) { + names_QList.push_back(static_cast(names_arr[i])); + } + QList parameters_QList; + parameters_QList.reserve(parameters.len); + QScxmlExecutableContent__ParameterInfo** parameters_arr = static_cast(parameters.data); + for(size_t i = 0; i < parameters.len; ++i) { + parameters_QList.push_back(*(parameters_arr[i])); + } + return new (std::nothrow) MiqtVirtualQScxmlInvokableServiceFactory(*invokeInfo, names_QList, parameters_QList, parent); +} + +void QScxmlInvokableServiceFactory_virtbase(QScxmlInvokableServiceFactory* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QScxmlInvokableServiceFactory_metaObject(const QScxmlInvokableServiceFactory* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QScxmlInvokableServiceFactory_metacast(QScxmlInvokableServiceFactory* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QScxmlInvokableServiceFactory_tr(const char* s) { + QString _ret = QScxmlInvokableServiceFactory::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; +} + +QScxmlInvokableService* QScxmlInvokableServiceFactory_invoke(QScxmlInvokableServiceFactory* self, QScxmlStateMachine* parentStateMachine) { + return self->invoke(parentStateMachine); +} + +QScxmlExecutableContent__InvokeInfo* QScxmlInvokableServiceFactory_invokeInfo(const QScxmlInvokableServiceFactory* self) { + const QScxmlExecutableContent::InvokeInfo& _ret = self->invokeInfo(); + // Cast returned reference into pointer + return const_cast(&_ret); +} + +struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ QScxmlInvokableServiceFactory_parameters(const QScxmlInvokableServiceFactory* self) { + const QList& _ret = self->parameters(); + // Convert QList<> from C++ memory to manually-managed C memory + QScxmlExecutableContent__ParameterInfo** _arr = static_cast(malloc(sizeof(QScxmlExecutableContent__ParameterInfo*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QScxmlExecutableContent::ParameterInfo(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +struct miqt_array /* of int */ QScxmlInvokableServiceFactory_names(const QScxmlInvokableServiceFactory* self) { + const QList& _ret = self->names(); + // Convert QList<> from C++ memory to manually-managed C memory + int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = _ret[i]; + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +struct miqt_string QScxmlInvokableServiceFactory_tr2(const char* s, const char* c) { + QString _ret = QScxmlInvokableServiceFactory::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 QScxmlInvokableServiceFactory_tr3(const char* s, const char* c, int n) { + QString _ret = QScxmlInvokableServiceFactory::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 QScxmlInvokableServiceFactory_override_virtual_invoke(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__invoke = slot; + return true; +} + +bool QScxmlInvokableServiceFactory_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QScxmlInvokableServiceFactory_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QScxmlInvokableServiceFactory::event(event); +} + +bool QScxmlInvokableServiceFactory_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QScxmlInvokableServiceFactory_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QScxmlInvokableServiceFactory::eventFilter(watched, event); +} + +bool QScxmlInvokableServiceFactory_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QScxmlInvokableServiceFactory_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QScxmlInvokableServiceFactory::timerEvent(event); +} + +bool QScxmlInvokableServiceFactory_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QScxmlInvokableServiceFactory_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QScxmlInvokableServiceFactory::childEvent(event); +} + +bool QScxmlInvokableServiceFactory_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QScxmlInvokableServiceFactory_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QScxmlInvokableServiceFactory::customEvent(event); +} + +bool QScxmlInvokableServiceFactory_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QScxmlInvokableServiceFactory_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlInvokableServiceFactory::connectNotify(*signal); +} + +bool QScxmlInvokableServiceFactory_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QScxmlInvokableServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlInvokableServiceFactory::disconnectNotify(*signal); +} + +QObject* QScxmlInvokableServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QScxmlInvokableServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QScxmlInvokableServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QScxmlInvokableServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QScxmlInvokableServiceFactory_delete(QScxmlInvokableServiceFactory* self) { + delete self; +} + +class MiqtVirtualQScxmlStaticScxmlServiceFactory final : public QScxmlStaticScxmlServiceFactory { +public: + + MiqtVirtualQScxmlStaticScxmlServiceFactory(const QMetaObject* metaObject, const QScxmlExecutableContent::InvokeInfo& invokeInfo, const QList& nameList, const QList& parameters): QScxmlStaticScxmlServiceFactory(metaObject, invokeInfo, nameList, parameters) {} + MiqtVirtualQScxmlStaticScxmlServiceFactory(const QMetaObject* metaObject, const QScxmlExecutableContent::InvokeInfo& invokeInfo, const QList& nameList, const QList& parameters, QObject* parent): QScxmlStaticScxmlServiceFactory(metaObject, invokeInfo, nameList, parameters, parent) {} + + virtual ~MiqtVirtualQScxmlStaticScxmlServiceFactory() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__invoke = 0; + + // Subclass to allow providing a Go implementation + virtual QScxmlInvokableService* invoke(QScxmlStateMachine* parentStateMachine) override { + if (handle__invoke == 0) { + return QScxmlStaticScxmlServiceFactory::invoke(parentStateMachine); + } + + QScxmlStateMachine* sigval1 = parentStateMachine; + QScxmlInvokableService* callback_return_value = miqt_exec_callback_QScxmlStaticScxmlServiceFactory_invoke(this, handle__invoke, sigval1); + return callback_return_value; + } + + friend QScxmlInvokableService* QScxmlStaticScxmlServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine); + + // 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 QScxmlStaticScxmlServiceFactory::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QScxmlStaticScxmlServiceFactory_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QScxmlStaticScxmlServiceFactory_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 QScxmlStaticScxmlServiceFactory::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QScxmlStaticScxmlServiceFactory_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QScxmlStaticScxmlServiceFactory_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) { + QScxmlStaticScxmlServiceFactory::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QScxmlStaticScxmlServiceFactory_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QScxmlStaticScxmlServiceFactory_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) { + QScxmlStaticScxmlServiceFactory::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QScxmlStaticScxmlServiceFactory_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QScxmlStaticScxmlServiceFactory_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) { + QScxmlStaticScxmlServiceFactory::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QScxmlStaticScxmlServiceFactory_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QScxmlStaticScxmlServiceFactory_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) { + QScxmlStaticScxmlServiceFactory::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlStaticScxmlServiceFactory_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QScxmlStaticScxmlServiceFactory_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) { + QScxmlStaticScxmlServiceFactory::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlStaticScxmlServiceFactory_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QScxmlStaticScxmlServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QScxmlStaticScxmlServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlStaticScxmlServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlStaticScxmlServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QScxmlStaticScxmlServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QScxmlStaticScxmlServiceFactory* QScxmlStaticScxmlServiceFactory_new(QMetaObject* metaObject, QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ nameList, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters) { + QList nameList_QList; + nameList_QList.reserve(nameList.len); + int* nameList_arr = static_cast(nameList.data); + for(size_t i = 0; i < nameList.len; ++i) { + nameList_QList.push_back(static_cast(nameList_arr[i])); + } + QList parameters_QList; + parameters_QList.reserve(parameters.len); + QScxmlExecutableContent__ParameterInfo** parameters_arr = static_cast(parameters.data); + for(size_t i = 0; i < parameters.len; ++i) { + parameters_QList.push_back(*(parameters_arr[i])); + } + return new (std::nothrow) MiqtVirtualQScxmlStaticScxmlServiceFactory(metaObject, *invokeInfo, nameList_QList, parameters_QList); +} + +QScxmlStaticScxmlServiceFactory* QScxmlStaticScxmlServiceFactory_new2(QMetaObject* metaObject, QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ nameList, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters, QObject* parent) { + QList nameList_QList; + nameList_QList.reserve(nameList.len); + int* nameList_arr = static_cast(nameList.data); + for(size_t i = 0; i < nameList.len; ++i) { + nameList_QList.push_back(static_cast(nameList_arr[i])); + } + QList parameters_QList; + parameters_QList.reserve(parameters.len); + QScxmlExecutableContent__ParameterInfo** parameters_arr = static_cast(parameters.data); + for(size_t i = 0; i < parameters.len; ++i) { + parameters_QList.push_back(*(parameters_arr[i])); + } + return new (std::nothrow) MiqtVirtualQScxmlStaticScxmlServiceFactory(metaObject, *invokeInfo, nameList_QList, parameters_QList, parent); +} + +void QScxmlStaticScxmlServiceFactory_virtbase(QScxmlStaticScxmlServiceFactory* src, QScxmlInvokableServiceFactory** outptr_QScxmlInvokableServiceFactory) { + *outptr_QScxmlInvokableServiceFactory = static_cast(src); +} + +QMetaObject* QScxmlStaticScxmlServiceFactory_metaObject(const QScxmlStaticScxmlServiceFactory* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QScxmlStaticScxmlServiceFactory_metacast(QScxmlStaticScxmlServiceFactory* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QScxmlStaticScxmlServiceFactory_tr(const char* s) { + QString _ret = QScxmlStaticScxmlServiceFactory::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; +} + +QScxmlInvokableService* QScxmlStaticScxmlServiceFactory_invoke(QScxmlStaticScxmlServiceFactory* self, QScxmlStateMachine* parentStateMachine) { + return self->invoke(parentStateMachine); +} + +struct miqt_string QScxmlStaticScxmlServiceFactory_tr2(const char* s, const char* c) { + QString _ret = QScxmlStaticScxmlServiceFactory::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 QScxmlStaticScxmlServiceFactory_tr3(const char* s, const char* c, int n) { + QString _ret = QScxmlStaticScxmlServiceFactory::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 QScxmlStaticScxmlServiceFactory_override_virtual_invoke(void* self, intptr_t slot) { + MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__invoke = slot; + return true; +} + +QScxmlInvokableService* QScxmlStaticScxmlServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine) { + return static_cast(self)->QScxmlStaticScxmlServiceFactory::invoke(parentStateMachine); +} + +bool QScxmlStaticScxmlServiceFactory_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QScxmlStaticScxmlServiceFactory_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QScxmlStaticScxmlServiceFactory::event(event); +} + +bool QScxmlStaticScxmlServiceFactory_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QScxmlStaticScxmlServiceFactory_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QScxmlStaticScxmlServiceFactory::eventFilter(watched, event); +} + +bool QScxmlStaticScxmlServiceFactory_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QScxmlStaticScxmlServiceFactory_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QScxmlStaticScxmlServiceFactory::timerEvent(event); +} + +bool QScxmlStaticScxmlServiceFactory_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QScxmlStaticScxmlServiceFactory_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QScxmlStaticScxmlServiceFactory::childEvent(event); +} + +bool QScxmlStaticScxmlServiceFactory_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QScxmlStaticScxmlServiceFactory_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QScxmlStaticScxmlServiceFactory::customEvent(event); +} + +bool QScxmlStaticScxmlServiceFactory_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QScxmlStaticScxmlServiceFactory_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlStaticScxmlServiceFactory::connectNotify(*signal); +} + +bool QScxmlStaticScxmlServiceFactory_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QScxmlStaticScxmlServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlStaticScxmlServiceFactory::disconnectNotify(*signal); +} + +QObject* QScxmlStaticScxmlServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QScxmlStaticScxmlServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QScxmlStaticScxmlServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QScxmlStaticScxmlServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QScxmlStaticScxmlServiceFactory_delete(QScxmlStaticScxmlServiceFactory* self) { + delete self; +} + +class MiqtVirtualQScxmlDynamicScxmlServiceFactory final : public QScxmlDynamicScxmlServiceFactory { +public: + + MiqtVirtualQScxmlDynamicScxmlServiceFactory(const QScxmlExecutableContent::InvokeInfo& invokeInfo, const QList& names, const QList& parameters): QScxmlDynamicScxmlServiceFactory(invokeInfo, names, parameters) {} + MiqtVirtualQScxmlDynamicScxmlServiceFactory(const QScxmlExecutableContent::InvokeInfo& invokeInfo, const QList& names, const QList& parameters, QObject* parent): QScxmlDynamicScxmlServiceFactory(invokeInfo, names, parameters, parent) {} + + virtual ~MiqtVirtualQScxmlDynamicScxmlServiceFactory() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__invoke = 0; + + // Subclass to allow providing a Go implementation + virtual QScxmlInvokableService* invoke(QScxmlStateMachine* parentStateMachine) override { + if (handle__invoke == 0) { + return QScxmlDynamicScxmlServiceFactory::invoke(parentStateMachine); + } + + QScxmlStateMachine* sigval1 = parentStateMachine; + QScxmlInvokableService* callback_return_value = miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_invoke(this, handle__invoke, sigval1); + return callback_return_value; + } + + friend QScxmlInvokableService* QScxmlDynamicScxmlServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine); + + // 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 QScxmlDynamicScxmlServiceFactory::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QScxmlDynamicScxmlServiceFactory_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 QScxmlDynamicScxmlServiceFactory::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QScxmlDynamicScxmlServiceFactory_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) { + QScxmlDynamicScxmlServiceFactory::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QScxmlDynamicScxmlServiceFactory_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) { + QScxmlDynamicScxmlServiceFactory::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QScxmlDynamicScxmlServiceFactory_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) { + QScxmlDynamicScxmlServiceFactory::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QScxmlDynamicScxmlServiceFactory_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) { + QScxmlDynamicScxmlServiceFactory::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QScxmlDynamicScxmlServiceFactory_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) { + QScxmlDynamicScxmlServiceFactory::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QScxmlDynamicScxmlServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QScxmlDynamicScxmlServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlDynamicScxmlServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlDynamicScxmlServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QScxmlDynamicScxmlServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QScxmlDynamicScxmlServiceFactory* QScxmlDynamicScxmlServiceFactory_new(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters) { + QList names_QList; + names_QList.reserve(names.len); + int* names_arr = static_cast(names.data); + for(size_t i = 0; i < names.len; ++i) { + names_QList.push_back(static_cast(names_arr[i])); + } + QList parameters_QList; + parameters_QList.reserve(parameters.len); + QScxmlExecutableContent__ParameterInfo** parameters_arr = static_cast(parameters.data); + for(size_t i = 0; i < parameters.len; ++i) { + parameters_QList.push_back(*(parameters_arr[i])); + } + return new (std::nothrow) MiqtVirtualQScxmlDynamicScxmlServiceFactory(*invokeInfo, names_QList, parameters_QList); +} + +QScxmlDynamicScxmlServiceFactory* QScxmlDynamicScxmlServiceFactory_new2(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters, QObject* parent) { + QList names_QList; + names_QList.reserve(names.len); + int* names_arr = static_cast(names.data); + for(size_t i = 0; i < names.len; ++i) { + names_QList.push_back(static_cast(names_arr[i])); + } + QList parameters_QList; + parameters_QList.reserve(parameters.len); + QScxmlExecutableContent__ParameterInfo** parameters_arr = static_cast(parameters.data); + for(size_t i = 0; i < parameters.len; ++i) { + parameters_QList.push_back(*(parameters_arr[i])); + } + return new (std::nothrow) MiqtVirtualQScxmlDynamicScxmlServiceFactory(*invokeInfo, names_QList, parameters_QList, parent); +} + +void QScxmlDynamicScxmlServiceFactory_virtbase(QScxmlDynamicScxmlServiceFactory* src, QScxmlInvokableServiceFactory** outptr_QScxmlInvokableServiceFactory) { + *outptr_QScxmlInvokableServiceFactory = static_cast(src); +} + +QMetaObject* QScxmlDynamicScxmlServiceFactory_metaObject(const QScxmlDynamicScxmlServiceFactory* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QScxmlDynamicScxmlServiceFactory_metacast(QScxmlDynamicScxmlServiceFactory* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QScxmlDynamicScxmlServiceFactory_tr(const char* s) { + QString _ret = QScxmlDynamicScxmlServiceFactory::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; +} + +QScxmlInvokableService* QScxmlDynamicScxmlServiceFactory_invoke(QScxmlDynamicScxmlServiceFactory* self, QScxmlStateMachine* parentStateMachine) { + return self->invoke(parentStateMachine); +} + +struct miqt_string QScxmlDynamicScxmlServiceFactory_tr2(const char* s, const char* c) { + QString _ret = QScxmlDynamicScxmlServiceFactory::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 QScxmlDynamicScxmlServiceFactory_tr3(const char* s, const char* c, int n) { + QString _ret = QScxmlDynamicScxmlServiceFactory::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 QScxmlDynamicScxmlServiceFactory_override_virtual_invoke(void* self, intptr_t slot) { + MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__invoke = slot; + return true; +} + +QScxmlInvokableService* QScxmlDynamicScxmlServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine) { + return static_cast(self)->QScxmlDynamicScxmlServiceFactory::invoke(parentStateMachine); +} + +bool QScxmlDynamicScxmlServiceFactory_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QScxmlDynamicScxmlServiceFactory_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QScxmlDynamicScxmlServiceFactory::event(event); +} + +bool QScxmlDynamicScxmlServiceFactory_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QScxmlDynamicScxmlServiceFactory_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QScxmlDynamicScxmlServiceFactory::eventFilter(watched, event); +} + +bool QScxmlDynamicScxmlServiceFactory_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QScxmlDynamicScxmlServiceFactory_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QScxmlDynamicScxmlServiceFactory::timerEvent(event); +} + +bool QScxmlDynamicScxmlServiceFactory_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QScxmlDynamicScxmlServiceFactory_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QScxmlDynamicScxmlServiceFactory::childEvent(event); +} + +bool QScxmlDynamicScxmlServiceFactory_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QScxmlDynamicScxmlServiceFactory_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QScxmlDynamicScxmlServiceFactory::customEvent(event); +} + +bool QScxmlDynamicScxmlServiceFactory_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QScxmlDynamicScxmlServiceFactory_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlDynamicScxmlServiceFactory::connectNotify(*signal); +} + +bool QScxmlDynamicScxmlServiceFactory_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QScxmlDynamicScxmlServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlDynamicScxmlServiceFactory::disconnectNotify(*signal); +} + +QObject* QScxmlDynamicScxmlServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QScxmlDynamicScxmlServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QScxmlDynamicScxmlServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QScxmlDynamicScxmlServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QScxmlDynamicScxmlServiceFactory_delete(QScxmlDynamicScxmlServiceFactory* self) { + delete self; +} + diff --git a/qt6/scxml/gen_qscxmlinvokableservice.go b/qt6/scxml/gen_qscxmlinvokableservice.go new file mode 100644 index 000000000..7d5e69cc1 --- /dev/null +++ b/qt6/scxml/gen_qscxmlinvokableservice.go @@ -0,0 +1,1705 @@ +package scxml + +/* + +#include "gen_qscxmlinvokableservice.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QScxmlInvokableService struct { + h *C.QScxmlInvokableService + *qt6.QObject +} + +func (this *QScxmlInvokableService) cPointer() *C.QScxmlInvokableService { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlInvokableService) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlInvokableService constructs the type using only CGO pointers. +func newQScxmlInvokableService(h *C.QScxmlInvokableService) *QScxmlInvokableService { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QScxmlInvokableService_virtbase(h, &outptr_QObject) + + return &QScxmlInvokableService{h: h, + QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQScxmlInvokableService constructs the type using only unsafe pointers. +func UnsafeNewQScxmlInvokableService(h unsafe.Pointer) *QScxmlInvokableService { + return newQScxmlInvokableService((*C.QScxmlInvokableService)(h)) +} + +// NewQScxmlInvokableService constructs a new QScxmlInvokableService object. +func NewQScxmlInvokableService(parentStateMachine *QScxmlStateMachine, parent *QScxmlInvokableServiceFactory) *QScxmlInvokableService { + + return newQScxmlInvokableService(C.QScxmlInvokableService_new(parentStateMachine.cPointer(), parent.cPointer())) +} + +func (this *QScxmlInvokableService) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlInvokableService_metaObject(this.h))) +} + +func (this *QScxmlInvokableService) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QScxmlInvokableService_metacast(this.h, param1_Cstring)) +} + +func QScxmlInvokableService_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QScxmlInvokableService_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlInvokableService) ParentStateMachine() *QScxmlStateMachine { + return newQScxmlStateMachine(C.QScxmlInvokableService_parentStateMachine(this.h)) +} + +func (this *QScxmlInvokableService) Start() bool { + return (bool)(C.QScxmlInvokableService_start(this.h)) +} + +func (this *QScxmlInvokableService) Id() string { + var _ms C.struct_miqt_string = C.QScxmlInvokableService_id(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlInvokableService) Name() string { + var _ms C.struct_miqt_string = C.QScxmlInvokableService_name(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlInvokableService) PostEvent(event *QScxmlEvent) { + C.QScxmlInvokableService_postEvent(this.h, event.cPointer()) +} + +func QScxmlInvokableService_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.QScxmlInvokableService_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QScxmlInvokableService_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.QScxmlInvokableService_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 +} + +// Sender can only be called from a QScxmlInvokableService that was directly constructed. +func (this *QScxmlInvokableService) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlInvokableService_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 QScxmlInvokableService that was directly constructed. +func (this *QScxmlInvokableService) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QScxmlInvokableService_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 QScxmlInvokableService that was directly constructed. +func (this *QScxmlInvokableService) 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.QScxmlInvokableService_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 QScxmlInvokableService that was directly constructed. +func (this *QScxmlInvokableService) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QScxmlInvokableService_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 *QScxmlInvokableService) OnStart(slot func() bool) { + ok := C.QScxmlInvokableService_override_virtual_start(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlInvokableService_start +func miqt_exec_callback_QScxmlInvokableService_start(self *C.QScxmlInvokableService, cb C.intptr_t) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func() bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc() + + return (C.bool)(virtualReturn) + +} +func (this *QScxmlInvokableService) OnId(slot func() string) { + ok := C.QScxmlInvokableService_override_virtual_id(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlInvokableService_id +func miqt_exec_callback_QScxmlInvokableService_id(self *C.QScxmlInvokableService, cb C.intptr_t) C.struct_miqt_string { + gofunc, ok := cgo.Handle(cb).Value().(func() string) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc() + virtualReturn_ms := C.struct_miqt_string{} + virtualReturn_ms.data = C.CString(virtualReturn) + virtualReturn_ms.len = C.size_t(len(virtualReturn)) + defer C.free(unsafe.Pointer(virtualReturn_ms.data)) + + return virtualReturn_ms + +} +func (this *QScxmlInvokableService) OnName(slot func() string) { + ok := C.QScxmlInvokableService_override_virtual_name(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlInvokableService_name +func miqt_exec_callback_QScxmlInvokableService_name(self *C.QScxmlInvokableService, cb C.intptr_t) C.struct_miqt_string { + gofunc, ok := cgo.Handle(cb).Value().(func() string) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc() + virtualReturn_ms := C.struct_miqt_string{} + virtualReturn_ms.data = C.CString(virtualReturn) + virtualReturn_ms.len = C.size_t(len(virtualReturn)) + defer C.free(unsafe.Pointer(virtualReturn_ms.data)) + + return virtualReturn_ms + +} +func (this *QScxmlInvokableService) OnPostEvent(slot func(event *QScxmlEvent)) { + ok := C.QScxmlInvokableService_override_virtual_postEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlInvokableService_postEvent +func miqt_exec_callback_QScxmlInvokableService_postEvent(self *C.QScxmlInvokableService, cb C.intptr_t, event *C.QScxmlEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(event *QScxmlEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQScxmlEvent(event) + + gofunc(slotval1) + +} + +func (this *QScxmlInvokableService) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QScxmlInvokableService_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlInvokableService) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QScxmlInvokableService_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_QScxmlInvokableService_event +func miqt_exec_callback_QScxmlInvokableService_event(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlInvokableService) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QScxmlInvokableService_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlInvokableService) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QScxmlInvokableService_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_QScxmlInvokableService_eventFilter +func miqt_exec_callback_QScxmlInvokableService_eventFilter(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlInvokableService) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QScxmlInvokableService_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QScxmlInvokableService) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QScxmlInvokableService_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_QScxmlInvokableService_timerEvent +func miqt_exec_callback_QScxmlInvokableService_timerEvent(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QScxmlInvokableService) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QScxmlInvokableService_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QScxmlInvokableService) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QScxmlInvokableService_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_QScxmlInvokableService_childEvent +func miqt_exec_callback_QScxmlInvokableService_childEvent(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QScxmlInvokableService) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QScxmlInvokableService_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QScxmlInvokableService) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QScxmlInvokableService_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_QScxmlInvokableService_customEvent +func miqt_exec_callback_QScxmlInvokableService_customEvent(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QScxmlInvokableService) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlInvokableService_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlInvokableService) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlInvokableService_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_QScxmlInvokableService_connectNotify +func miqt_exec_callback_QScxmlInvokableService_connectNotify(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QScxmlInvokableService) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlInvokableService_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlInvokableService) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlInvokableService_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_QScxmlInvokableService_disconnectNotify +func miqt_exec_callback_QScxmlInvokableService_disconnectNotify(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QScxmlInvokableService) Delete() { + C.QScxmlInvokableService_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 *QScxmlInvokableService) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlInvokableService) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type QScxmlInvokableServiceFactory struct { + h *C.QScxmlInvokableServiceFactory + *qt6.QObject +} + +func (this *QScxmlInvokableServiceFactory) cPointer() *C.QScxmlInvokableServiceFactory { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlInvokableServiceFactory) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlInvokableServiceFactory constructs the type using only CGO pointers. +func newQScxmlInvokableServiceFactory(h *C.QScxmlInvokableServiceFactory) *QScxmlInvokableServiceFactory { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QScxmlInvokableServiceFactory_virtbase(h, &outptr_QObject) + + return &QScxmlInvokableServiceFactory{h: h, + QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQScxmlInvokableServiceFactory constructs the type using only unsafe pointers. +func UnsafeNewQScxmlInvokableServiceFactory(h unsafe.Pointer) *QScxmlInvokableServiceFactory { + return newQScxmlInvokableServiceFactory((*C.QScxmlInvokableServiceFactory)(h)) +} + +// NewQScxmlInvokableServiceFactory constructs a new QScxmlInvokableServiceFactory object. +func NewQScxmlInvokableServiceFactory(invokeInfo *QScxmlExecutableContent__InvokeInfo, names []int, parameters []QScxmlExecutableContent__ParameterInfo) *QScxmlInvokableServiceFactory { + names_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(names)))) + defer C.free(unsafe.Pointer(names_CArray)) + for i := range names { + names_CArray[i] = (C.int)(names[i]) + } + names_ma := C.struct_miqt_array{len: C.size_t(len(names)), data: unsafe.Pointer(names_CArray)} + parameters_CArray := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(C.malloc(C.size_t(8 * len(parameters)))) + defer C.free(unsafe.Pointer(parameters_CArray)) + for i := range parameters { + parameters_CArray[i] = parameters[i].cPointer() + } + parameters_ma := C.struct_miqt_array{len: C.size_t(len(parameters)), data: unsafe.Pointer(parameters_CArray)} + + return newQScxmlInvokableServiceFactory(C.QScxmlInvokableServiceFactory_new(invokeInfo.cPointer(), names_ma, parameters_ma)) +} + +// NewQScxmlInvokableServiceFactory2 constructs a new QScxmlInvokableServiceFactory object. +func NewQScxmlInvokableServiceFactory2(invokeInfo *QScxmlExecutableContent__InvokeInfo, names []int, parameters []QScxmlExecutableContent__ParameterInfo, parent *qt6.QObject) *QScxmlInvokableServiceFactory { + names_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(names)))) + defer C.free(unsafe.Pointer(names_CArray)) + for i := range names { + names_CArray[i] = (C.int)(names[i]) + } + names_ma := C.struct_miqt_array{len: C.size_t(len(names)), data: unsafe.Pointer(names_CArray)} + parameters_CArray := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(C.malloc(C.size_t(8 * len(parameters)))) + defer C.free(unsafe.Pointer(parameters_CArray)) + for i := range parameters { + parameters_CArray[i] = parameters[i].cPointer() + } + parameters_ma := C.struct_miqt_array{len: C.size_t(len(parameters)), data: unsafe.Pointer(parameters_CArray)} + + return newQScxmlInvokableServiceFactory(C.QScxmlInvokableServiceFactory_new2(invokeInfo.cPointer(), names_ma, parameters_ma, (*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QScxmlInvokableServiceFactory) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlInvokableServiceFactory_metaObject(this.h))) +} + +func (this *QScxmlInvokableServiceFactory) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QScxmlInvokableServiceFactory_metacast(this.h, param1_Cstring)) +} + +func QScxmlInvokableServiceFactory_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QScxmlInvokableServiceFactory_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlInvokableServiceFactory) Invoke(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService { + return newQScxmlInvokableService(C.QScxmlInvokableServiceFactory_invoke(this.h, parentStateMachine.cPointer())) +} + +func (this *QScxmlInvokableServiceFactory) InvokeInfo() *QScxmlExecutableContent__InvokeInfo { + return newQScxmlExecutableContent__InvokeInfo(C.QScxmlInvokableServiceFactory_invokeInfo(this.h)) +} + +func (this *QScxmlInvokableServiceFactory) Parameters() []QScxmlExecutableContent__ParameterInfo { + var _ma C.struct_miqt_array = C.QScxmlInvokableServiceFactory_parameters(this.h) + _ret := make([]QScxmlExecutableContent__ParameterInfo, int(_ma.len)) + _outCast := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := newQScxmlExecutableContent__ParameterInfo(_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 *QScxmlInvokableServiceFactory) Names() []int { + var _ma C.struct_miqt_array = C.QScxmlInvokableServiceFactory_names(this.h) + _ret := make([]int, int(_ma.len)) + _outCast := (*[0xffff]C.int)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _ret[i] = (int)(_outCast[i]) + } + return _ret +} + +func QScxmlInvokableServiceFactory_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.QScxmlInvokableServiceFactory_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QScxmlInvokableServiceFactory_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.QScxmlInvokableServiceFactory_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 +} + +// Sender can only be called from a QScxmlInvokableServiceFactory that was directly constructed. +func (this *QScxmlInvokableServiceFactory) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlInvokableServiceFactory_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 QScxmlInvokableServiceFactory that was directly constructed. +func (this *QScxmlInvokableServiceFactory) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QScxmlInvokableServiceFactory_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 QScxmlInvokableServiceFactory that was directly constructed. +func (this *QScxmlInvokableServiceFactory) 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.QScxmlInvokableServiceFactory_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 QScxmlInvokableServiceFactory that was directly constructed. +func (this *QScxmlInvokableServiceFactory) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QScxmlInvokableServiceFactory_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 *QScxmlInvokableServiceFactory) OnInvoke(slot func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) { + ok := C.QScxmlInvokableServiceFactory_override_virtual_invoke(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlInvokableServiceFactory_invoke +func miqt_exec_callback_QScxmlInvokableServiceFactory_invoke(self *C.QScxmlInvokableServiceFactory, cb C.intptr_t, parentStateMachine *C.QScxmlStateMachine) *C.QScxmlInvokableService { + gofunc, ok := cgo.Handle(cb).Value().(func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQScxmlStateMachine(parentStateMachine) + + virtualReturn := gofunc(slotval1) + + return virtualReturn.cPointer() + +} + +func (this *QScxmlInvokableServiceFactory) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QScxmlInvokableServiceFactory_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlInvokableServiceFactory) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_event +func miqt_exec_callback_QScxmlInvokableServiceFactory_event(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlInvokableServiceFactory) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QScxmlInvokableServiceFactory_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlInvokableServiceFactory) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_eventFilter +func miqt_exec_callback_QScxmlInvokableServiceFactory_eventFilter(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlInvokableServiceFactory) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QScxmlInvokableServiceFactory_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QScxmlInvokableServiceFactory) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_timerEvent +func miqt_exec_callback_QScxmlInvokableServiceFactory_timerEvent(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QScxmlInvokableServiceFactory) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QScxmlInvokableServiceFactory_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QScxmlInvokableServiceFactory) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_childEvent +func miqt_exec_callback_QScxmlInvokableServiceFactory_childEvent(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QScxmlInvokableServiceFactory) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QScxmlInvokableServiceFactory_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QScxmlInvokableServiceFactory) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_customEvent +func miqt_exec_callback_QScxmlInvokableServiceFactory_customEvent(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QScxmlInvokableServiceFactory) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlInvokableServiceFactory_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlInvokableServiceFactory) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_connectNotify +func miqt_exec_callback_QScxmlInvokableServiceFactory_connectNotify(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QScxmlInvokableServiceFactory) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlInvokableServiceFactory_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlInvokableServiceFactory) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_disconnectNotify +func miqt_exec_callback_QScxmlInvokableServiceFactory_disconnectNotify(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QScxmlInvokableServiceFactory) Delete() { + C.QScxmlInvokableServiceFactory_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 *QScxmlInvokableServiceFactory) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlInvokableServiceFactory) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type QScxmlStaticScxmlServiceFactory struct { + h *C.QScxmlStaticScxmlServiceFactory + *QScxmlInvokableServiceFactory +} + +func (this *QScxmlStaticScxmlServiceFactory) cPointer() *C.QScxmlStaticScxmlServiceFactory { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlStaticScxmlServiceFactory) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlStaticScxmlServiceFactory constructs the type using only CGO pointers. +func newQScxmlStaticScxmlServiceFactory(h *C.QScxmlStaticScxmlServiceFactory) *QScxmlStaticScxmlServiceFactory { + if h == nil { + return nil + } + var outptr_QScxmlInvokableServiceFactory *C.QScxmlInvokableServiceFactory = nil + C.QScxmlStaticScxmlServiceFactory_virtbase(h, &outptr_QScxmlInvokableServiceFactory) + + return &QScxmlStaticScxmlServiceFactory{h: h, + QScxmlInvokableServiceFactory: newQScxmlInvokableServiceFactory(outptr_QScxmlInvokableServiceFactory)} +} + +// UnsafeNewQScxmlStaticScxmlServiceFactory constructs the type using only unsafe pointers. +func UnsafeNewQScxmlStaticScxmlServiceFactory(h unsafe.Pointer) *QScxmlStaticScxmlServiceFactory { + return newQScxmlStaticScxmlServiceFactory((*C.QScxmlStaticScxmlServiceFactory)(h)) +} + +// NewQScxmlStaticScxmlServiceFactory constructs a new QScxmlStaticScxmlServiceFactory object. +func NewQScxmlStaticScxmlServiceFactory(metaObject *qt6.QMetaObject, invokeInfo *QScxmlExecutableContent__InvokeInfo, nameList []int, parameters []QScxmlExecutableContent__ParameterInfo) *QScxmlStaticScxmlServiceFactory { + nameList_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(nameList)))) + defer C.free(unsafe.Pointer(nameList_CArray)) + for i := range nameList { + nameList_CArray[i] = (C.int)(nameList[i]) + } + nameList_ma := C.struct_miqt_array{len: C.size_t(len(nameList)), data: unsafe.Pointer(nameList_CArray)} + parameters_CArray := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(C.malloc(C.size_t(8 * len(parameters)))) + defer C.free(unsafe.Pointer(parameters_CArray)) + for i := range parameters { + parameters_CArray[i] = parameters[i].cPointer() + } + parameters_ma := C.struct_miqt_array{len: C.size_t(len(parameters)), data: unsafe.Pointer(parameters_CArray)} + + return newQScxmlStaticScxmlServiceFactory(C.QScxmlStaticScxmlServiceFactory_new((*C.QMetaObject)(metaObject.UnsafePointer()), invokeInfo.cPointer(), nameList_ma, parameters_ma)) +} + +// NewQScxmlStaticScxmlServiceFactory2 constructs a new QScxmlStaticScxmlServiceFactory object. +func NewQScxmlStaticScxmlServiceFactory2(metaObject *qt6.QMetaObject, invokeInfo *QScxmlExecutableContent__InvokeInfo, nameList []int, parameters []QScxmlExecutableContent__ParameterInfo, parent *qt6.QObject) *QScxmlStaticScxmlServiceFactory { + nameList_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(nameList)))) + defer C.free(unsafe.Pointer(nameList_CArray)) + for i := range nameList { + nameList_CArray[i] = (C.int)(nameList[i]) + } + nameList_ma := C.struct_miqt_array{len: C.size_t(len(nameList)), data: unsafe.Pointer(nameList_CArray)} + parameters_CArray := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(C.malloc(C.size_t(8 * len(parameters)))) + defer C.free(unsafe.Pointer(parameters_CArray)) + for i := range parameters { + parameters_CArray[i] = parameters[i].cPointer() + } + parameters_ma := C.struct_miqt_array{len: C.size_t(len(parameters)), data: unsafe.Pointer(parameters_CArray)} + + return newQScxmlStaticScxmlServiceFactory(C.QScxmlStaticScxmlServiceFactory_new2((*C.QMetaObject)(metaObject.UnsafePointer()), invokeInfo.cPointer(), nameList_ma, parameters_ma, (*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QScxmlStaticScxmlServiceFactory) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlStaticScxmlServiceFactory_metaObject(this.h))) +} + +func (this *QScxmlStaticScxmlServiceFactory) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QScxmlStaticScxmlServiceFactory_metacast(this.h, param1_Cstring)) +} + +func QScxmlStaticScxmlServiceFactory_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QScxmlStaticScxmlServiceFactory_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlStaticScxmlServiceFactory) Invoke(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService { + return newQScxmlInvokableService(C.QScxmlStaticScxmlServiceFactory_invoke(this.h, parentStateMachine.cPointer())) +} + +func QScxmlStaticScxmlServiceFactory_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.QScxmlStaticScxmlServiceFactory_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QScxmlStaticScxmlServiceFactory_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.QScxmlStaticScxmlServiceFactory_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 +} + +// Sender can only be called from a QScxmlStaticScxmlServiceFactory that was directly constructed. +func (this *QScxmlStaticScxmlServiceFactory) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlStaticScxmlServiceFactory_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 QScxmlStaticScxmlServiceFactory that was directly constructed. +func (this *QScxmlStaticScxmlServiceFactory) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QScxmlStaticScxmlServiceFactory_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 QScxmlStaticScxmlServiceFactory that was directly constructed. +func (this *QScxmlStaticScxmlServiceFactory) 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.QScxmlStaticScxmlServiceFactory_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 QScxmlStaticScxmlServiceFactory that was directly constructed. +func (this *QScxmlStaticScxmlServiceFactory) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QScxmlStaticScxmlServiceFactory_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 *QScxmlStaticScxmlServiceFactory) callVirtualBase_Invoke(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService { + + return newQScxmlInvokableService(C.QScxmlStaticScxmlServiceFactory_virtualbase_invoke(unsafe.Pointer(this.h), parentStateMachine.cPointer())) + +} +func (this *QScxmlStaticScxmlServiceFactory) OnInvoke(slot func(super func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService, parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) { + ok := C.QScxmlStaticScxmlServiceFactory_override_virtual_invoke(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlStaticScxmlServiceFactory_invoke +func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_invoke(self *C.QScxmlStaticScxmlServiceFactory, cb C.intptr_t, parentStateMachine *C.QScxmlStateMachine) *C.QScxmlInvokableService { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService, parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQScxmlStateMachine(parentStateMachine) + + virtualReturn := gofunc((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_Invoke, slotval1) + + return virtualReturn.cPointer() + +} + +func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QScxmlStaticScxmlServiceFactory_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlStaticScxmlServiceFactory) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_event +func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_event(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QScxmlStaticScxmlServiceFactory_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlStaticScxmlServiceFactory) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_eventFilter +func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_eventFilter(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QScxmlStaticScxmlServiceFactory_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QScxmlStaticScxmlServiceFactory) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_timerEvent +func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_timerEvent(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QScxmlStaticScxmlServiceFactory_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QScxmlStaticScxmlServiceFactory) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_childEvent +func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_childEvent(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QScxmlStaticScxmlServiceFactory_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QScxmlStaticScxmlServiceFactory) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_customEvent +func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_customEvent(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlStaticScxmlServiceFactory_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlStaticScxmlServiceFactory) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_connectNotify +func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_connectNotify(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlStaticScxmlServiceFactory_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlStaticScxmlServiceFactory) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_disconnectNotify +func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_disconnectNotify(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QScxmlStaticScxmlServiceFactory) Delete() { + C.QScxmlStaticScxmlServiceFactory_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 *QScxmlStaticScxmlServiceFactory) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlStaticScxmlServiceFactory) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type QScxmlDynamicScxmlServiceFactory struct { + h *C.QScxmlDynamicScxmlServiceFactory + *QScxmlInvokableServiceFactory +} + +func (this *QScxmlDynamicScxmlServiceFactory) cPointer() *C.QScxmlDynamicScxmlServiceFactory { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlDynamicScxmlServiceFactory) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlDynamicScxmlServiceFactory constructs the type using only CGO pointers. +func newQScxmlDynamicScxmlServiceFactory(h *C.QScxmlDynamicScxmlServiceFactory) *QScxmlDynamicScxmlServiceFactory { + if h == nil { + return nil + } + var outptr_QScxmlInvokableServiceFactory *C.QScxmlInvokableServiceFactory = nil + C.QScxmlDynamicScxmlServiceFactory_virtbase(h, &outptr_QScxmlInvokableServiceFactory) + + return &QScxmlDynamicScxmlServiceFactory{h: h, + QScxmlInvokableServiceFactory: newQScxmlInvokableServiceFactory(outptr_QScxmlInvokableServiceFactory)} +} + +// UnsafeNewQScxmlDynamicScxmlServiceFactory constructs the type using only unsafe pointers. +func UnsafeNewQScxmlDynamicScxmlServiceFactory(h unsafe.Pointer) *QScxmlDynamicScxmlServiceFactory { + return newQScxmlDynamicScxmlServiceFactory((*C.QScxmlDynamicScxmlServiceFactory)(h)) +} + +// NewQScxmlDynamicScxmlServiceFactory constructs a new QScxmlDynamicScxmlServiceFactory object. +func NewQScxmlDynamicScxmlServiceFactory(invokeInfo *QScxmlExecutableContent__InvokeInfo, names []int, parameters []QScxmlExecutableContent__ParameterInfo) *QScxmlDynamicScxmlServiceFactory { + names_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(names)))) + defer C.free(unsafe.Pointer(names_CArray)) + for i := range names { + names_CArray[i] = (C.int)(names[i]) + } + names_ma := C.struct_miqt_array{len: C.size_t(len(names)), data: unsafe.Pointer(names_CArray)} + parameters_CArray := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(C.malloc(C.size_t(8 * len(parameters)))) + defer C.free(unsafe.Pointer(parameters_CArray)) + for i := range parameters { + parameters_CArray[i] = parameters[i].cPointer() + } + parameters_ma := C.struct_miqt_array{len: C.size_t(len(parameters)), data: unsafe.Pointer(parameters_CArray)} + + return newQScxmlDynamicScxmlServiceFactory(C.QScxmlDynamicScxmlServiceFactory_new(invokeInfo.cPointer(), names_ma, parameters_ma)) +} + +// NewQScxmlDynamicScxmlServiceFactory2 constructs a new QScxmlDynamicScxmlServiceFactory object. +func NewQScxmlDynamicScxmlServiceFactory2(invokeInfo *QScxmlExecutableContent__InvokeInfo, names []int, parameters []QScxmlExecutableContent__ParameterInfo, parent *qt6.QObject) *QScxmlDynamicScxmlServiceFactory { + names_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(names)))) + defer C.free(unsafe.Pointer(names_CArray)) + for i := range names { + names_CArray[i] = (C.int)(names[i]) + } + names_ma := C.struct_miqt_array{len: C.size_t(len(names)), data: unsafe.Pointer(names_CArray)} + parameters_CArray := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(C.malloc(C.size_t(8 * len(parameters)))) + defer C.free(unsafe.Pointer(parameters_CArray)) + for i := range parameters { + parameters_CArray[i] = parameters[i].cPointer() + } + parameters_ma := C.struct_miqt_array{len: C.size_t(len(parameters)), data: unsafe.Pointer(parameters_CArray)} + + return newQScxmlDynamicScxmlServiceFactory(C.QScxmlDynamicScxmlServiceFactory_new2(invokeInfo.cPointer(), names_ma, parameters_ma, (*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QScxmlDynamicScxmlServiceFactory) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlDynamicScxmlServiceFactory_metaObject(this.h))) +} + +func (this *QScxmlDynamicScxmlServiceFactory) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QScxmlDynamicScxmlServiceFactory_metacast(this.h, param1_Cstring)) +} + +func QScxmlDynamicScxmlServiceFactory_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QScxmlDynamicScxmlServiceFactory_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlDynamicScxmlServiceFactory) Invoke(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService { + return newQScxmlInvokableService(C.QScxmlDynamicScxmlServiceFactory_invoke(this.h, parentStateMachine.cPointer())) +} + +func QScxmlDynamicScxmlServiceFactory_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.QScxmlDynamicScxmlServiceFactory_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QScxmlDynamicScxmlServiceFactory_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.QScxmlDynamicScxmlServiceFactory_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 +} + +// Sender can only be called from a QScxmlDynamicScxmlServiceFactory that was directly constructed. +func (this *QScxmlDynamicScxmlServiceFactory) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlDynamicScxmlServiceFactory_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 QScxmlDynamicScxmlServiceFactory that was directly constructed. +func (this *QScxmlDynamicScxmlServiceFactory) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QScxmlDynamicScxmlServiceFactory_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 QScxmlDynamicScxmlServiceFactory that was directly constructed. +func (this *QScxmlDynamicScxmlServiceFactory) 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.QScxmlDynamicScxmlServiceFactory_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 QScxmlDynamicScxmlServiceFactory that was directly constructed. +func (this *QScxmlDynamicScxmlServiceFactory) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QScxmlDynamicScxmlServiceFactory_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 *QScxmlDynamicScxmlServiceFactory) callVirtualBase_Invoke(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService { + + return newQScxmlInvokableService(C.QScxmlDynamicScxmlServiceFactory_virtualbase_invoke(unsafe.Pointer(this.h), parentStateMachine.cPointer())) + +} +func (this *QScxmlDynamicScxmlServiceFactory) OnInvoke(slot func(super func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService, parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) { + ok := C.QScxmlDynamicScxmlServiceFactory_override_virtual_invoke(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_invoke +func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_invoke(self *C.QScxmlDynamicScxmlServiceFactory, cb C.intptr_t, parentStateMachine *C.QScxmlStateMachine) *C.QScxmlInvokableService { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService, parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQScxmlStateMachine(parentStateMachine) + + virtualReturn := gofunc((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_Invoke, slotval1) + + return virtualReturn.cPointer() + +} + +func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QScxmlDynamicScxmlServiceFactory_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlDynamicScxmlServiceFactory) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_event +func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_event(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QScxmlDynamicScxmlServiceFactory_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlDynamicScxmlServiceFactory) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_eventFilter +func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_eventFilter(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QScxmlDynamicScxmlServiceFactory_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QScxmlDynamicScxmlServiceFactory) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_timerEvent +func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_timerEvent(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QScxmlDynamicScxmlServiceFactory_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QScxmlDynamicScxmlServiceFactory) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_childEvent +func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_childEvent(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QScxmlDynamicScxmlServiceFactory_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QScxmlDynamicScxmlServiceFactory) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_customEvent +func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_customEvent(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlDynamicScxmlServiceFactory_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlDynamicScxmlServiceFactory) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_connectNotify +func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_connectNotify(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlDynamicScxmlServiceFactory_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlDynamicScxmlServiceFactory) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_disconnectNotify +func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_disconnectNotify(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QScxmlDynamicScxmlServiceFactory) Delete() { + C.QScxmlDynamicScxmlServiceFactory_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 *QScxmlDynamicScxmlServiceFactory) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlDynamicScxmlServiceFactory) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/scxml/gen_qscxmlinvokableservice.h b/qt6/scxml/gen_qscxmlinvokableservice.h new file mode 100644 index 000000000..7500783e7 --- /dev/null +++ b/qt6/scxml/gen_qscxmlinvokableservice.h @@ -0,0 +1,209 @@ +#pragma once +#ifndef MIQT_QT6_SCXML_GEN_QSCXMLINVOKABLESERVICE_H +#define MIQT_QT6_SCXML_GEN_QSCXMLINVOKABLESERVICE_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 QScxmlDynamicScxmlServiceFactory; +class QScxmlEvent; +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__InvokeInfo) +typedef QScxmlExecutableContent::InvokeInfo QScxmlExecutableContent__InvokeInfo; +#else +class QScxmlExecutableContent__InvokeInfo; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ParameterInfo) +typedef QScxmlExecutableContent::ParameterInfo QScxmlExecutableContent__ParameterInfo; +#else +class QScxmlExecutableContent__ParameterInfo; +#endif +class QScxmlInvokableService; +class QScxmlInvokableServiceFactory; +class QScxmlStateMachine; +class QScxmlStaticScxmlServiceFactory; +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 QScxmlDynamicScxmlServiceFactory QScxmlDynamicScxmlServiceFactory; +typedef struct QScxmlEvent QScxmlEvent; +typedef struct QScxmlExecutableContent__InvokeInfo QScxmlExecutableContent__InvokeInfo; +typedef struct QScxmlExecutableContent__ParameterInfo QScxmlExecutableContent__ParameterInfo; +typedef struct QScxmlInvokableService QScxmlInvokableService; +typedef struct QScxmlInvokableServiceFactory QScxmlInvokableServiceFactory; +typedef struct QScxmlStateMachine QScxmlStateMachine; +typedef struct QScxmlStaticScxmlServiceFactory QScxmlStaticScxmlServiceFactory; +typedef struct QTimerEvent QTimerEvent; +#endif + +QScxmlInvokableService* QScxmlInvokableService_new(QScxmlStateMachine* parentStateMachine, QScxmlInvokableServiceFactory* parent); +void QScxmlInvokableService_virtbase(QScxmlInvokableService* src, QObject** outptr_QObject); +QMetaObject* QScxmlInvokableService_metaObject(const QScxmlInvokableService* self); +void* QScxmlInvokableService_metacast(QScxmlInvokableService* self, const char* param1); +struct miqt_string QScxmlInvokableService_tr(const char* s); +QScxmlStateMachine* QScxmlInvokableService_parentStateMachine(const QScxmlInvokableService* self); +bool QScxmlInvokableService_start(QScxmlInvokableService* self); +struct miqt_string QScxmlInvokableService_id(const QScxmlInvokableService* self); +struct miqt_string QScxmlInvokableService_name(const QScxmlInvokableService* self); +void QScxmlInvokableService_postEvent(QScxmlInvokableService* self, QScxmlEvent* event); +struct miqt_string QScxmlInvokableService_tr2(const char* s, const char* c); +struct miqt_string QScxmlInvokableService_tr3(const char* s, const char* c, int n); + +bool QScxmlInvokableService_override_virtual_start(void* self, intptr_t slot); +bool QScxmlInvokableService_virtualbase_start(void* self); +bool QScxmlInvokableService_override_virtual_id(void* self, intptr_t slot); +struct miqt_string QScxmlInvokableService_virtualbase_id(const void* self); +bool QScxmlInvokableService_override_virtual_name(void* self, intptr_t slot); +struct miqt_string QScxmlInvokableService_virtualbase_name(const void* self); +bool QScxmlInvokableService_override_virtual_postEvent(void* self, intptr_t slot); +void QScxmlInvokableService_virtualbase_postEvent(void* self, QScxmlEvent* event); +bool QScxmlInvokableService_override_virtual_event(void* self, intptr_t slot); +bool QScxmlInvokableService_virtualbase_event(void* self, QEvent* event); +bool QScxmlInvokableService_override_virtual_eventFilter(void* self, intptr_t slot); +bool QScxmlInvokableService_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QScxmlInvokableService_override_virtual_timerEvent(void* self, intptr_t slot); +void QScxmlInvokableService_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QScxmlInvokableService_override_virtual_childEvent(void* self, intptr_t slot); +void QScxmlInvokableService_virtualbase_childEvent(void* self, QChildEvent* event); +bool QScxmlInvokableService_override_virtual_customEvent(void* self, intptr_t slot); +void QScxmlInvokableService_virtualbase_customEvent(void* self, QEvent* event); +bool QScxmlInvokableService_override_virtual_connectNotify(void* self, intptr_t slot); +void QScxmlInvokableService_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QScxmlInvokableService_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QScxmlInvokableService_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QScxmlInvokableService_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QScxmlInvokableService_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QScxmlInvokableService_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QScxmlInvokableService_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QScxmlInvokableService_delete(QScxmlInvokableService* self); + +QScxmlInvokableServiceFactory* QScxmlInvokableServiceFactory_new(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters); +QScxmlInvokableServiceFactory* QScxmlInvokableServiceFactory_new2(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters, QObject* parent); +void QScxmlInvokableServiceFactory_virtbase(QScxmlInvokableServiceFactory* src, QObject** outptr_QObject); +QMetaObject* QScxmlInvokableServiceFactory_metaObject(const QScxmlInvokableServiceFactory* self); +void* QScxmlInvokableServiceFactory_metacast(QScxmlInvokableServiceFactory* self, const char* param1); +struct miqt_string QScxmlInvokableServiceFactory_tr(const char* s); +QScxmlInvokableService* QScxmlInvokableServiceFactory_invoke(QScxmlInvokableServiceFactory* self, QScxmlStateMachine* parentStateMachine); +QScxmlExecutableContent__InvokeInfo* QScxmlInvokableServiceFactory_invokeInfo(const QScxmlInvokableServiceFactory* self); +struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ QScxmlInvokableServiceFactory_parameters(const QScxmlInvokableServiceFactory* self); +struct miqt_array /* of int */ QScxmlInvokableServiceFactory_names(const QScxmlInvokableServiceFactory* self); +struct miqt_string QScxmlInvokableServiceFactory_tr2(const char* s, const char* c); +struct miqt_string QScxmlInvokableServiceFactory_tr3(const char* s, const char* c, int n); + +bool QScxmlInvokableServiceFactory_override_virtual_invoke(void* self, intptr_t slot); +QScxmlInvokableService* QScxmlInvokableServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine); +bool QScxmlInvokableServiceFactory_override_virtual_event(void* self, intptr_t slot); +bool QScxmlInvokableServiceFactory_virtualbase_event(void* self, QEvent* event); +bool QScxmlInvokableServiceFactory_override_virtual_eventFilter(void* self, intptr_t slot); +bool QScxmlInvokableServiceFactory_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QScxmlInvokableServiceFactory_override_virtual_timerEvent(void* self, intptr_t slot); +void QScxmlInvokableServiceFactory_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QScxmlInvokableServiceFactory_override_virtual_childEvent(void* self, intptr_t slot); +void QScxmlInvokableServiceFactory_virtualbase_childEvent(void* self, QChildEvent* event); +bool QScxmlInvokableServiceFactory_override_virtual_customEvent(void* self, intptr_t slot); +void QScxmlInvokableServiceFactory_virtualbase_customEvent(void* self, QEvent* event); +bool QScxmlInvokableServiceFactory_override_virtual_connectNotify(void* self, intptr_t slot); +void QScxmlInvokableServiceFactory_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QScxmlInvokableServiceFactory_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QScxmlInvokableServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QScxmlInvokableServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QScxmlInvokableServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QScxmlInvokableServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QScxmlInvokableServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QScxmlInvokableServiceFactory_delete(QScxmlInvokableServiceFactory* self); + +QScxmlStaticScxmlServiceFactory* QScxmlStaticScxmlServiceFactory_new(QMetaObject* metaObject, QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ nameList, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters); +QScxmlStaticScxmlServiceFactory* QScxmlStaticScxmlServiceFactory_new2(QMetaObject* metaObject, QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ nameList, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters, QObject* parent); +void QScxmlStaticScxmlServiceFactory_virtbase(QScxmlStaticScxmlServiceFactory* src, QScxmlInvokableServiceFactory** outptr_QScxmlInvokableServiceFactory); +QMetaObject* QScxmlStaticScxmlServiceFactory_metaObject(const QScxmlStaticScxmlServiceFactory* self); +void* QScxmlStaticScxmlServiceFactory_metacast(QScxmlStaticScxmlServiceFactory* self, const char* param1); +struct miqt_string QScxmlStaticScxmlServiceFactory_tr(const char* s); +QScxmlInvokableService* QScxmlStaticScxmlServiceFactory_invoke(QScxmlStaticScxmlServiceFactory* self, QScxmlStateMachine* parentStateMachine); +struct miqt_string QScxmlStaticScxmlServiceFactory_tr2(const char* s, const char* c); +struct miqt_string QScxmlStaticScxmlServiceFactory_tr3(const char* s, const char* c, int n); + +bool QScxmlStaticScxmlServiceFactory_override_virtual_invoke(void* self, intptr_t slot); +QScxmlInvokableService* QScxmlStaticScxmlServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine); +bool QScxmlStaticScxmlServiceFactory_override_virtual_event(void* self, intptr_t slot); +bool QScxmlStaticScxmlServiceFactory_virtualbase_event(void* self, QEvent* event); +bool QScxmlStaticScxmlServiceFactory_override_virtual_eventFilter(void* self, intptr_t slot); +bool QScxmlStaticScxmlServiceFactory_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QScxmlStaticScxmlServiceFactory_override_virtual_timerEvent(void* self, intptr_t slot); +void QScxmlStaticScxmlServiceFactory_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QScxmlStaticScxmlServiceFactory_override_virtual_childEvent(void* self, intptr_t slot); +void QScxmlStaticScxmlServiceFactory_virtualbase_childEvent(void* self, QChildEvent* event); +bool QScxmlStaticScxmlServiceFactory_override_virtual_customEvent(void* self, intptr_t slot); +void QScxmlStaticScxmlServiceFactory_virtualbase_customEvent(void* self, QEvent* event); +bool QScxmlStaticScxmlServiceFactory_override_virtual_connectNotify(void* self, intptr_t slot); +void QScxmlStaticScxmlServiceFactory_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QScxmlStaticScxmlServiceFactory_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QScxmlStaticScxmlServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QScxmlStaticScxmlServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QScxmlStaticScxmlServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QScxmlStaticScxmlServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QScxmlStaticScxmlServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QScxmlStaticScxmlServiceFactory_delete(QScxmlStaticScxmlServiceFactory* self); + +QScxmlDynamicScxmlServiceFactory* QScxmlDynamicScxmlServiceFactory_new(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters); +QScxmlDynamicScxmlServiceFactory* QScxmlDynamicScxmlServiceFactory_new2(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters, QObject* parent); +void QScxmlDynamicScxmlServiceFactory_virtbase(QScxmlDynamicScxmlServiceFactory* src, QScxmlInvokableServiceFactory** outptr_QScxmlInvokableServiceFactory); +QMetaObject* QScxmlDynamicScxmlServiceFactory_metaObject(const QScxmlDynamicScxmlServiceFactory* self); +void* QScxmlDynamicScxmlServiceFactory_metacast(QScxmlDynamicScxmlServiceFactory* self, const char* param1); +struct miqt_string QScxmlDynamicScxmlServiceFactory_tr(const char* s); +QScxmlInvokableService* QScxmlDynamicScxmlServiceFactory_invoke(QScxmlDynamicScxmlServiceFactory* self, QScxmlStateMachine* parentStateMachine); +struct miqt_string QScxmlDynamicScxmlServiceFactory_tr2(const char* s, const char* c); +struct miqt_string QScxmlDynamicScxmlServiceFactory_tr3(const char* s, const char* c, int n); + +bool QScxmlDynamicScxmlServiceFactory_override_virtual_invoke(void* self, intptr_t slot); +QScxmlInvokableService* QScxmlDynamicScxmlServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine); +bool QScxmlDynamicScxmlServiceFactory_override_virtual_event(void* self, intptr_t slot); +bool QScxmlDynamicScxmlServiceFactory_virtualbase_event(void* self, QEvent* event); +bool QScxmlDynamicScxmlServiceFactory_override_virtual_eventFilter(void* self, intptr_t slot); +bool QScxmlDynamicScxmlServiceFactory_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QScxmlDynamicScxmlServiceFactory_override_virtual_timerEvent(void* self, intptr_t slot); +void QScxmlDynamicScxmlServiceFactory_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QScxmlDynamicScxmlServiceFactory_override_virtual_childEvent(void* self, intptr_t slot); +void QScxmlDynamicScxmlServiceFactory_virtualbase_childEvent(void* self, QChildEvent* event); +bool QScxmlDynamicScxmlServiceFactory_override_virtual_customEvent(void* self, intptr_t slot); +void QScxmlDynamicScxmlServiceFactory_virtualbase_customEvent(void* self, QEvent* event); +bool QScxmlDynamicScxmlServiceFactory_override_virtual_connectNotify(void* self, intptr_t slot); +void QScxmlDynamicScxmlServiceFactory_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QScxmlDynamicScxmlServiceFactory_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QScxmlDynamicScxmlServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QScxmlDynamicScxmlServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QScxmlDynamicScxmlServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QScxmlDynamicScxmlServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QScxmlDynamicScxmlServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QScxmlDynamicScxmlServiceFactory_delete(QScxmlDynamicScxmlServiceFactory* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/scxml/gen_qscxmlnulldatamodel.cpp b/qt6/scxml/gen_qscxmlnulldatamodel.cpp new file mode 100644 index 000000000..68d94b8df --- /dev/null +++ b/qt6/scxml/gen_qscxmlnulldatamodel.cpp @@ -0,0 +1,901 @@ +#include +#include +#include +#include +#include +#include +#include +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlDataModel__ForeachLoopBody +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qscxmlnulldatamodel.h" + +#ifdef __cplusplus +extern "C" { +#endif + +bool miqt_exec_callback_QScxmlNullDataModel_setup(QScxmlNullDataModel*, intptr_t, struct miqt_map /* of struct miqt_string to QVariant* */ ); +struct miqt_string miqt_exec_callback_QScxmlNullDataModel_evaluateToString(QScxmlNullDataModel*, intptr_t, int, bool*); +bool miqt_exec_callback_QScxmlNullDataModel_evaluateToBool(QScxmlNullDataModel*, intptr_t, int, bool*); +QVariant* miqt_exec_callback_QScxmlNullDataModel_evaluateToVariant(QScxmlNullDataModel*, intptr_t, int, bool*); +void miqt_exec_callback_QScxmlNullDataModel_evaluateToVoid(QScxmlNullDataModel*, intptr_t, int, bool*); +void miqt_exec_callback_QScxmlNullDataModel_evaluateAssignment(QScxmlNullDataModel*, intptr_t, int, bool*); +void miqt_exec_callback_QScxmlNullDataModel_evaluateInitialization(QScxmlNullDataModel*, intptr_t, int, bool*); +void miqt_exec_callback_QScxmlNullDataModel_evaluateForeach(QScxmlNullDataModel*, intptr_t, int, bool*, QScxmlDataModel__ForeachLoopBody*); +void miqt_exec_callback_QScxmlNullDataModel_setScxmlEvent(QScxmlNullDataModel*, intptr_t, QScxmlEvent*); +QVariant* miqt_exec_callback_QScxmlNullDataModel_scxmlProperty(const QScxmlNullDataModel*, intptr_t, struct miqt_string); +bool miqt_exec_callback_QScxmlNullDataModel_hasScxmlProperty(const QScxmlNullDataModel*, intptr_t, struct miqt_string); +bool miqt_exec_callback_QScxmlNullDataModel_setScxmlProperty(QScxmlNullDataModel*, intptr_t, struct miqt_string, QVariant*, struct miqt_string); +bool miqt_exec_callback_QScxmlNullDataModel_event(QScxmlNullDataModel*, intptr_t, QEvent*); +bool miqt_exec_callback_QScxmlNullDataModel_eventFilter(QScxmlNullDataModel*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QScxmlNullDataModel_timerEvent(QScxmlNullDataModel*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QScxmlNullDataModel_childEvent(QScxmlNullDataModel*, intptr_t, QChildEvent*); +void miqt_exec_callback_QScxmlNullDataModel_customEvent(QScxmlNullDataModel*, intptr_t, QEvent*); +void miqt_exec_callback_QScxmlNullDataModel_connectNotify(QScxmlNullDataModel*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QScxmlNullDataModel_disconnectNotify(QScxmlNullDataModel*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQScxmlNullDataModel final : public QScxmlNullDataModel { +public: + + MiqtVirtualQScxmlNullDataModel(): QScxmlNullDataModel() {} + MiqtVirtualQScxmlNullDataModel(QObject* parent): QScxmlNullDataModel(parent) {} + + virtual ~MiqtVirtualQScxmlNullDataModel() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__setup = 0; + + // Subclass to allow providing a Go implementation + virtual bool setup(const QVariantMap& initialDataValues) override { + if (handle__setup == 0) { + return QScxmlNullDataModel::setup(initialDataValues); + } + + const QVariantMap& initialDataValues_ret = initialDataValues; + // Convert QMap<> from C++ memory to manually-managed C memory + struct miqt_string* initialDataValues_karr = static_cast(malloc(sizeof(struct miqt_string) * initialDataValues_ret.size())); + QVariant** initialDataValues_varr = static_cast(malloc(sizeof(QVariant*) * initialDataValues_ret.size())); + int initialDataValues_ctr = 0; + for (auto initialDataValues_itr = initialDataValues_ret.keyValueBegin(); initialDataValues_itr != initialDataValues_ret.keyValueEnd(); ++initialDataValues_itr) { + QString initialDataValues_mapkey_ret = initialDataValues_itr->first; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray initialDataValues_mapkey_b = initialDataValues_mapkey_ret.toUtf8(); + struct miqt_string initialDataValues_mapkey_ms; + initialDataValues_mapkey_ms.len = initialDataValues_mapkey_b.length(); + initialDataValues_mapkey_ms.data = static_cast(malloc(initialDataValues_mapkey_ms.len)); + memcpy(initialDataValues_mapkey_ms.data, initialDataValues_mapkey_b.data(), initialDataValues_mapkey_ms.len); + initialDataValues_karr[initialDataValues_ctr] = initialDataValues_mapkey_ms; + initialDataValues_varr[initialDataValues_ctr] = new QVariant(initialDataValues_itr->second); + initialDataValues_ctr++; + } + struct miqt_map initialDataValues_out; + initialDataValues_out.len = initialDataValues_ret.size(); + initialDataValues_out.keys = static_cast(initialDataValues_karr); + initialDataValues_out.values = static_cast(initialDataValues_varr); + struct miqt_map /* of struct miqt_string to QVariant* */ sigval1 = initialDataValues_out; + bool callback_return_value = miqt_exec_callback_QScxmlNullDataModel_setup(this, handle__setup, sigval1); + return callback_return_value; + } + + friend bool QScxmlNullDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateToString = 0; + + // Subclass to allow providing a Go implementation + virtual QString evaluateToString(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateToString == 0) { + return QScxmlNullDataModel::evaluateToString(id, ok); + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + struct miqt_string callback_return_value = miqt_exec_callback_QScxmlNullDataModel_evaluateToString(this, handle__evaluateToString, sigval1, sigval2); + QString callback_return_value_QString = QString::fromUtf8(callback_return_value.data, callback_return_value.len); + return callback_return_value_QString; + } + + friend struct miqt_string QScxmlNullDataModel_virtualbase_evaluateToString(void* self, int id, bool* ok); + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateToBool = 0; + + // Subclass to allow providing a Go implementation + virtual bool evaluateToBool(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateToBool == 0) { + return QScxmlNullDataModel::evaluateToBool(id, ok); + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + bool callback_return_value = miqt_exec_callback_QScxmlNullDataModel_evaluateToBool(this, handle__evaluateToBool, sigval1, sigval2); + return callback_return_value; + } + + friend bool QScxmlNullDataModel_virtualbase_evaluateToBool(void* self, int id, bool* ok); + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateToVariant = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant evaluateToVariant(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateToVariant == 0) { + return QScxmlNullDataModel::evaluateToVariant(id, ok); + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + QVariant* callback_return_value = miqt_exec_callback_QScxmlNullDataModel_evaluateToVariant(this, handle__evaluateToVariant, sigval1, sigval2); + return *callback_return_value; + } + + friend QVariant* QScxmlNullDataModel_virtualbase_evaluateToVariant(void* self, int id, bool* ok); + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateToVoid = 0; + + // Subclass to allow providing a Go implementation + virtual void evaluateToVoid(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateToVoid == 0) { + QScxmlNullDataModel::evaluateToVoid(id, ok); + return; + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + miqt_exec_callback_QScxmlNullDataModel_evaluateToVoid(this, handle__evaluateToVoid, sigval1, sigval2); + + } + + friend void QScxmlNullDataModel_virtualbase_evaluateToVoid(void* self, int id, bool* ok); + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateAssignment = 0; + + // Subclass to allow providing a Go implementation + virtual void evaluateAssignment(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateAssignment == 0) { + QScxmlNullDataModel::evaluateAssignment(id, ok); + return; + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + miqt_exec_callback_QScxmlNullDataModel_evaluateAssignment(this, handle__evaluateAssignment, sigval1, sigval2); + + } + + friend void QScxmlNullDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok); + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateInitialization = 0; + + // Subclass to allow providing a Go implementation + virtual void evaluateInitialization(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { + if (handle__evaluateInitialization == 0) { + QScxmlNullDataModel::evaluateInitialization(id, ok); + return; + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + miqt_exec_callback_QScxmlNullDataModel_evaluateInitialization(this, handle__evaluateInitialization, sigval1, sigval2); + + } + + friend void QScxmlNullDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok); + + // cgo.Handle value for overwritten implementation + intptr_t handle__evaluateForeach = 0; + + // Subclass to allow providing a Go implementation + virtual void evaluateForeach(QScxmlExecutableContent::EvaluatorId id, bool* ok, QScxmlDataModel::ForeachLoopBody* body) override { + if (handle__evaluateForeach == 0) { + QScxmlNullDataModel::evaluateForeach(id, ok, body); + return; + } + + QScxmlExecutableContent::EvaluatorId id_ret = id; + int sigval1 = static_cast(id_ret); + bool* sigval2 = ok; + QScxmlDataModel__ForeachLoopBody* sigval3 = body; + miqt_exec_callback_QScxmlNullDataModel_evaluateForeach(this, handle__evaluateForeach, sigval1, sigval2, sigval3); + + } + + friend void QScxmlNullDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setScxmlEvent = 0; + + // Subclass to allow providing a Go implementation + virtual void setScxmlEvent(const QScxmlEvent& event) override { + if (handle__setScxmlEvent == 0) { + QScxmlNullDataModel::setScxmlEvent(event); + return; + } + + const QScxmlEvent& event_ret = event; + // Cast returned reference into pointer + QScxmlEvent* sigval1 = const_cast(&event_ret); + miqt_exec_callback_QScxmlNullDataModel_setScxmlEvent(this, handle__setScxmlEvent, sigval1); + + } + + friend void QScxmlNullDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__scxmlProperty = 0; + + // Subclass to allow providing a Go implementation + virtual QVariant scxmlProperty(const QString& name) const override { + if (handle__scxmlProperty == 0) { + return QScxmlNullDataModel::scxmlProperty(name); + } + + const QString name_ret = name; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray name_b = name_ret.toUtf8(); + struct miqt_string name_ms; + name_ms.len = name_b.length(); + name_ms.data = static_cast(malloc(name_ms.len)); + memcpy(name_ms.data, name_b.data(), name_ms.len); + struct miqt_string sigval1 = name_ms; + QVariant* callback_return_value = miqt_exec_callback_QScxmlNullDataModel_scxmlProperty(this, handle__scxmlProperty, sigval1); + return *callback_return_value; + } + + friend QVariant* QScxmlNullDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name); + + // cgo.Handle value for overwritten implementation + intptr_t handle__hasScxmlProperty = 0; + + // Subclass to allow providing a Go implementation + virtual bool hasScxmlProperty(const QString& name) const override { + if (handle__hasScxmlProperty == 0) { + return QScxmlNullDataModel::hasScxmlProperty(name); + } + + const QString name_ret = name; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray name_b = name_ret.toUtf8(); + struct miqt_string name_ms; + name_ms.len = name_b.length(); + name_ms.data = static_cast(malloc(name_ms.len)); + memcpy(name_ms.data, name_b.data(), name_ms.len); + struct miqt_string sigval1 = name_ms; + bool callback_return_value = miqt_exec_callback_QScxmlNullDataModel_hasScxmlProperty(this, handle__hasScxmlProperty, sigval1); + return callback_return_value; + } + + friend bool QScxmlNullDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name); + + // cgo.Handle value for overwritten implementation + intptr_t handle__setScxmlProperty = 0; + + // Subclass to allow providing a Go implementation + virtual bool setScxmlProperty(const QString& name, const QVariant& value, const QString& context) override { + if (handle__setScxmlProperty == 0) { + return QScxmlNullDataModel::setScxmlProperty(name, value, context); + } + + const QString name_ret = name; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray name_b = name_ret.toUtf8(); + struct miqt_string name_ms; + name_ms.len = name_b.length(); + name_ms.data = static_cast(malloc(name_ms.len)); + memcpy(name_ms.data, name_b.data(), name_ms.len); + struct miqt_string sigval1 = name_ms; + const QVariant& value_ret = value; + // Cast returned reference into pointer + QVariant* sigval2 = const_cast(&value_ret); + const QString context_ret = context; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray context_b = context_ret.toUtf8(); + struct miqt_string context_ms; + context_ms.len = context_b.length(); + context_ms.data = static_cast(malloc(context_ms.len)); + memcpy(context_ms.data, context_b.data(), context_ms.len); + struct miqt_string sigval3 = context_ms; + bool callback_return_value = miqt_exec_callback_QScxmlNullDataModel_setScxmlProperty(this, handle__setScxmlProperty, sigval1, sigval2, sigval3); + return callback_return_value; + } + + friend bool QScxmlNullDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context); + + // 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 QScxmlNullDataModel::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QScxmlNullDataModel_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QScxmlNullDataModel_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 QScxmlNullDataModel::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QScxmlNullDataModel_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QScxmlNullDataModel_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) { + QScxmlNullDataModel::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QScxmlNullDataModel_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QScxmlNullDataModel_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) { + QScxmlNullDataModel::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QScxmlNullDataModel_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QScxmlNullDataModel_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) { + QScxmlNullDataModel::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QScxmlNullDataModel_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QScxmlNullDataModel_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) { + QScxmlNullDataModel::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlNullDataModel_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QScxmlNullDataModel_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) { + QScxmlNullDataModel::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QScxmlNullDataModel_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QScxmlNullDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QScxmlNullDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlNullDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QScxmlNullDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QScxmlNullDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QScxmlNullDataModel* QScxmlNullDataModel_new() { + return new (std::nothrow) MiqtVirtualQScxmlNullDataModel(); +} + +QScxmlNullDataModel* QScxmlNullDataModel_new2(QObject* parent) { + return new (std::nothrow) MiqtVirtualQScxmlNullDataModel(parent); +} + +void QScxmlNullDataModel_virtbase(QScxmlNullDataModel* src, QScxmlDataModel** outptr_QScxmlDataModel) { + *outptr_QScxmlDataModel = static_cast(src); +} + +QMetaObject* QScxmlNullDataModel_metaObject(const QScxmlNullDataModel* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QScxmlNullDataModel_metacast(QScxmlNullDataModel* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QScxmlNullDataModel_tr(const char* s) { + QString _ret = QScxmlNullDataModel::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; +} + +bool QScxmlNullDataModel_setup(QScxmlNullDataModel* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues) { + QVariantMap initialDataValues_QMap; + struct miqt_string* initialDataValues_karr = static_cast(initialDataValues.keys); + QVariant** initialDataValues_varr = static_cast(initialDataValues.values); + for(size_t i = 0; i < initialDataValues.len; ++i) { + QString initialDataValues_karr_i_QString = QString::fromUtf8(initialDataValues_karr[i].data, initialDataValues_karr[i].len); + initialDataValues_QMap[initialDataValues_karr_i_QString] = *(initialDataValues_varr[i]); + } + return self->setup(initialDataValues_QMap); +} + +struct miqt_string QScxmlNullDataModel_evaluateToString(QScxmlNullDataModel* self, int id, bool* ok) { + QString _ret = self->evaluateToString(static_cast(id), ok); + // 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 QScxmlNullDataModel_evaluateToBool(QScxmlNullDataModel* self, int id, bool* ok) { + return self->evaluateToBool(static_cast(id), ok); +} + +QVariant* QScxmlNullDataModel_evaluateToVariant(QScxmlNullDataModel* self, int id, bool* ok) { + return new QVariant(self->evaluateToVariant(static_cast(id), ok)); +} + +void QScxmlNullDataModel_evaluateToVoid(QScxmlNullDataModel* self, int id, bool* ok) { + self->evaluateToVoid(static_cast(id), ok); +} + +void QScxmlNullDataModel_evaluateAssignment(QScxmlNullDataModel* self, int id, bool* ok) { + self->evaluateAssignment(static_cast(id), ok); +} + +void QScxmlNullDataModel_evaluateInitialization(QScxmlNullDataModel* self, int id, bool* ok) { + self->evaluateInitialization(static_cast(id), ok); +} + +void QScxmlNullDataModel_evaluateForeach(QScxmlNullDataModel* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body) { + self->evaluateForeach(static_cast(id), ok, body); +} + +void QScxmlNullDataModel_setScxmlEvent(QScxmlNullDataModel* self, QScxmlEvent* event) { + self->setScxmlEvent(*event); +} + +QVariant* QScxmlNullDataModel_scxmlProperty(const QScxmlNullDataModel* self, struct miqt_string name) { + QString name_QString = QString::fromUtf8(name.data, name.len); + return new QVariant(self->scxmlProperty(name_QString)); +} + +bool QScxmlNullDataModel_hasScxmlProperty(const QScxmlNullDataModel* self, struct miqt_string name) { + QString name_QString = QString::fromUtf8(name.data, name.len); + return self->hasScxmlProperty(name_QString); +} + +bool QScxmlNullDataModel_setScxmlProperty(QScxmlNullDataModel* self, struct miqt_string name, QVariant* value, struct miqt_string context) { + QString name_QString = QString::fromUtf8(name.data, name.len); + QString context_QString = QString::fromUtf8(context.data, context.len); + return self->setScxmlProperty(name_QString, *value, context_QString); +} + +struct miqt_string QScxmlNullDataModel_tr2(const char* s, const char* c) { + QString _ret = QScxmlNullDataModel::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 QScxmlNullDataModel_tr3(const char* s, const char* c, int n) { + QString _ret = QScxmlNullDataModel::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 QScxmlNullDataModel_override_virtual_setup(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setup = slot; + return true; +} + +bool QScxmlNullDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues) { + QVariantMap initialDataValues_QMap; + struct miqt_string* initialDataValues_karr = static_cast(initialDataValues.keys); + QVariant** initialDataValues_varr = static_cast(initialDataValues.values); + for(size_t i = 0; i < initialDataValues.len; ++i) { + QString initialDataValues_karr_i_QString = QString::fromUtf8(initialDataValues_karr[i].data, initialDataValues_karr[i].len); + initialDataValues_QMap[initialDataValues_karr_i_QString] = *(initialDataValues_varr[i]); + } + return static_cast(self)->QScxmlNullDataModel::setup(initialDataValues_QMap); +} + +bool QScxmlNullDataModel_override_virtual_evaluateToString(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateToString = slot; + return true; +} + +struct miqt_string QScxmlNullDataModel_virtualbase_evaluateToString(void* self, int id, bool* ok) { + QString _ret = static_cast(self)->QScxmlNullDataModel::evaluateToString(static_cast(id), ok); + // 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 QScxmlNullDataModel_override_virtual_evaluateToBool(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateToBool = slot; + return true; +} + +bool QScxmlNullDataModel_virtualbase_evaluateToBool(void* self, int id, bool* ok) { + return static_cast(self)->QScxmlNullDataModel::evaluateToBool(static_cast(id), ok); +} + +bool QScxmlNullDataModel_override_virtual_evaluateToVariant(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateToVariant = slot; + return true; +} + +QVariant* QScxmlNullDataModel_virtualbase_evaluateToVariant(void* self, int id, bool* ok) { + return new QVariant(static_cast(self)->QScxmlNullDataModel::evaluateToVariant(static_cast(id), ok)); +} + +bool QScxmlNullDataModel_override_virtual_evaluateToVoid(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateToVoid = slot; + return true; +} + +void QScxmlNullDataModel_virtualbase_evaluateToVoid(void* self, int id, bool* ok) { + static_cast(self)->QScxmlNullDataModel::evaluateToVoid(static_cast(id), ok); +} + +bool QScxmlNullDataModel_override_virtual_evaluateAssignment(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateAssignment = slot; + return true; +} + +void QScxmlNullDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok) { + static_cast(self)->QScxmlNullDataModel::evaluateAssignment(static_cast(id), ok); +} + +bool QScxmlNullDataModel_override_virtual_evaluateInitialization(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateInitialization = slot; + return true; +} + +void QScxmlNullDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok) { + static_cast(self)->QScxmlNullDataModel::evaluateInitialization(static_cast(id), ok); +} + +bool QScxmlNullDataModel_override_virtual_evaluateForeach(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__evaluateForeach = slot; + return true; +} + +void QScxmlNullDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body) { + static_cast(self)->QScxmlNullDataModel::evaluateForeach(static_cast(id), ok, body); +} + +bool QScxmlNullDataModel_override_virtual_setScxmlEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setScxmlEvent = slot; + return true; +} + +void QScxmlNullDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* event) { + static_cast(self)->QScxmlNullDataModel::setScxmlEvent(*event); +} + +bool QScxmlNullDataModel_override_virtual_scxmlProperty(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__scxmlProperty = slot; + return true; +} + +QVariant* QScxmlNullDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name) { + QString name_QString = QString::fromUtf8(name.data, name.len); + return new QVariant(static_cast(self)->QScxmlNullDataModel::scxmlProperty(name_QString)); +} + +bool QScxmlNullDataModel_override_virtual_hasScxmlProperty(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__hasScxmlProperty = slot; + return true; +} + +bool QScxmlNullDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name) { + QString name_QString = QString::fromUtf8(name.data, name.len); + return static_cast(self)->QScxmlNullDataModel::hasScxmlProperty(name_QString); +} + +bool QScxmlNullDataModel_override_virtual_setScxmlProperty(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setScxmlProperty = slot; + return true; +} + +bool QScxmlNullDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context) { + QString name_QString = QString::fromUtf8(name.data, name.len); + QString context_QString = QString::fromUtf8(context.data, context.len); + return static_cast(self)->QScxmlNullDataModel::setScxmlProperty(name_QString, *value, context_QString); +} + +bool QScxmlNullDataModel_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QScxmlNullDataModel_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QScxmlNullDataModel::event(event); +} + +bool QScxmlNullDataModel_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QScxmlNullDataModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QScxmlNullDataModel::eventFilter(watched, event); +} + +bool QScxmlNullDataModel_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QScxmlNullDataModel_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QScxmlNullDataModel::timerEvent(event); +} + +bool QScxmlNullDataModel_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QScxmlNullDataModel_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QScxmlNullDataModel::childEvent(event); +} + +bool QScxmlNullDataModel_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QScxmlNullDataModel_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QScxmlNullDataModel::customEvent(event); +} + +bool QScxmlNullDataModel_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QScxmlNullDataModel_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlNullDataModel::connectNotify(*signal); +} + +bool QScxmlNullDataModel_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QScxmlNullDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QScxmlNullDataModel::disconnectNotify(*signal); +} + +QObject* QScxmlNullDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QScxmlNullDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QScxmlNullDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QScxmlNullDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QScxmlNullDataModel_delete(QScxmlNullDataModel* self) { + delete self; +} + diff --git a/qt6/scxml/gen_qscxmlnulldatamodel.go b/qt6/scxml/gen_qscxmlnulldatamodel.go new file mode 100644 index 000000000..b34b1a9b6 --- /dev/null +++ b/qt6/scxml/gen_qscxmlnulldatamodel.go @@ -0,0 +1,872 @@ +package scxml + +/* + +#include "gen_qscxmlnulldatamodel.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QScxmlNullDataModel struct { + h *C.QScxmlNullDataModel + *QScxmlDataModel +} + +func (this *QScxmlNullDataModel) cPointer() *C.QScxmlNullDataModel { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlNullDataModel) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlNullDataModel constructs the type using only CGO pointers. +func newQScxmlNullDataModel(h *C.QScxmlNullDataModel) *QScxmlNullDataModel { + if h == nil { + return nil + } + var outptr_QScxmlDataModel *C.QScxmlDataModel = nil + C.QScxmlNullDataModel_virtbase(h, &outptr_QScxmlDataModel) + + return &QScxmlNullDataModel{h: h, + QScxmlDataModel: newQScxmlDataModel(outptr_QScxmlDataModel)} +} + +// UnsafeNewQScxmlNullDataModel constructs the type using only unsafe pointers. +func UnsafeNewQScxmlNullDataModel(h unsafe.Pointer) *QScxmlNullDataModel { + return newQScxmlNullDataModel((*C.QScxmlNullDataModel)(h)) +} + +// NewQScxmlNullDataModel constructs a new QScxmlNullDataModel object. +func NewQScxmlNullDataModel() *QScxmlNullDataModel { + + return newQScxmlNullDataModel(C.QScxmlNullDataModel_new()) +} + +// NewQScxmlNullDataModel2 constructs a new QScxmlNullDataModel object. +func NewQScxmlNullDataModel2(parent *qt6.QObject) *QScxmlNullDataModel { + + return newQScxmlNullDataModel(C.QScxmlNullDataModel_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QScxmlNullDataModel) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlNullDataModel_metaObject(this.h))) +} + +func (this *QScxmlNullDataModel) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QScxmlNullDataModel_metacast(this.h, param1_Cstring)) +} + +func QScxmlNullDataModel_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QScxmlNullDataModel_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlNullDataModel) Setup(initialDataValues map[string]qt6.QVariant) bool { + initialDataValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialDataValues)))) + defer C.free(unsafe.Pointer(initialDataValues_Keys_CArray)) + initialDataValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialDataValues)))) + defer C.free(unsafe.Pointer(initialDataValues_Values_CArray)) + initialDataValues_ctr := 0 + for initialDataValues_k, initialDataValues_v := range initialDataValues { + initialDataValues_k_ms := C.struct_miqt_string{} + initialDataValues_k_ms.data = C.CString(initialDataValues_k) + initialDataValues_k_ms.len = C.size_t(len(initialDataValues_k)) + defer C.free(unsafe.Pointer(initialDataValues_k_ms.data)) + initialDataValues_Keys_CArray[initialDataValues_ctr] = initialDataValues_k_ms + initialDataValues_Values_CArray[initialDataValues_ctr] = (*C.QVariant)(initialDataValues_v.UnsafePointer()) + initialDataValues_ctr++ + } + initialDataValues_mm := C.struct_miqt_map{ + len: C.size_t(len(initialDataValues)), + keys: unsafe.Pointer(initialDataValues_Keys_CArray), + values: unsafe.Pointer(initialDataValues_Values_CArray), + } + return (bool)(C.QScxmlNullDataModel_setup(this.h, initialDataValues_mm)) +} + +func (this *QScxmlNullDataModel) EvaluateToString(id int, ok *bool) string { + var _ms C.struct_miqt_string = C.QScxmlNullDataModel_evaluateToString(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlNullDataModel) EvaluateToBool(id int, ok *bool) bool { + return (bool)(C.QScxmlNullDataModel_evaluateToBool(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok)))) +} + +func (this *QScxmlNullDataModel) EvaluateToVariant(id int, ok *bool) *qt6.QVariant { + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlNullDataModel_evaluateToVariant(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QScxmlNullDataModel) EvaluateToVoid(id int, ok *bool) { + C.QScxmlNullDataModel_evaluateToVoid(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) +} + +func (this *QScxmlNullDataModel) EvaluateAssignment(id int, ok *bool) { + C.QScxmlNullDataModel_evaluateAssignment(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) +} + +func (this *QScxmlNullDataModel) EvaluateInitialization(id int, ok *bool) { + C.QScxmlNullDataModel_evaluateInitialization(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) +} + +func (this *QScxmlNullDataModel) EvaluateForeach(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody) { + C.QScxmlNullDataModel_evaluateForeach(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok)), body.cPointer()) +} + +func (this *QScxmlNullDataModel) SetScxmlEvent(event *QScxmlEvent) { + C.QScxmlNullDataModel_setScxmlEvent(this.h, event.cPointer()) +} + +func (this *QScxmlNullDataModel) ScxmlProperty(name string) *qt6.QVariant { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlNullDataModel_scxmlProperty(this.h, name_ms))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QScxmlNullDataModel) HasScxmlProperty(name string) bool { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + return (bool)(C.QScxmlNullDataModel_hasScxmlProperty(this.h, name_ms)) +} + +func (this *QScxmlNullDataModel) SetScxmlProperty(name string, value *qt6.QVariant, context string) bool { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + context_ms := C.struct_miqt_string{} + context_ms.data = C.CString(context) + context_ms.len = C.size_t(len(context)) + defer C.free(unsafe.Pointer(context_ms.data)) + return (bool)(C.QScxmlNullDataModel_setScxmlProperty(this.h, name_ms, (*C.QVariant)(value.UnsafePointer()), context_ms)) +} + +func QScxmlNullDataModel_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.QScxmlNullDataModel_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QScxmlNullDataModel_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.QScxmlNullDataModel_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 +} + +// Sender can only be called from a QScxmlNullDataModel that was directly constructed. +func (this *QScxmlNullDataModel) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlNullDataModel_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 QScxmlNullDataModel that was directly constructed. +func (this *QScxmlNullDataModel) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QScxmlNullDataModel_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 QScxmlNullDataModel that was directly constructed. +func (this *QScxmlNullDataModel) 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.QScxmlNullDataModel_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 QScxmlNullDataModel that was directly constructed. +func (this *QScxmlNullDataModel) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QScxmlNullDataModel_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 *QScxmlNullDataModel) callVirtualBase_Setup(initialDataValues map[string]qt6.QVariant) bool { + initialDataValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialDataValues)))) + defer C.free(unsafe.Pointer(initialDataValues_Keys_CArray)) + initialDataValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialDataValues)))) + defer C.free(unsafe.Pointer(initialDataValues_Values_CArray)) + initialDataValues_ctr := 0 + for initialDataValues_k, initialDataValues_v := range initialDataValues { + initialDataValues_k_ms := C.struct_miqt_string{} + initialDataValues_k_ms.data = C.CString(initialDataValues_k) + initialDataValues_k_ms.len = C.size_t(len(initialDataValues_k)) + defer C.free(unsafe.Pointer(initialDataValues_k_ms.data)) + initialDataValues_Keys_CArray[initialDataValues_ctr] = initialDataValues_k_ms + initialDataValues_Values_CArray[initialDataValues_ctr] = (*C.QVariant)(initialDataValues_v.UnsafePointer()) + initialDataValues_ctr++ + } + initialDataValues_mm := C.struct_miqt_map{ + len: C.size_t(len(initialDataValues)), + keys: unsafe.Pointer(initialDataValues_Keys_CArray), + values: unsafe.Pointer(initialDataValues_Values_CArray), + } + + return (bool)(C.QScxmlNullDataModel_virtualbase_setup(unsafe.Pointer(this.h), initialDataValues_mm)) + +} +func (this *QScxmlNullDataModel) OnSetup(slot func(super func(initialDataValues map[string]qt6.QVariant) bool, initialDataValues map[string]qt6.QVariant) bool) { + ok := C.QScxmlNullDataModel_override_virtual_setup(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlNullDataModel_setup +func miqt_exec_callback_QScxmlNullDataModel_setup(self *C.QScxmlNullDataModel, cb C.intptr_t, initialDataValues C.struct_miqt_map) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(initialDataValues map[string]qt6.QVariant) bool, initialDataValues map[string]qt6.QVariant) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var initialDataValues_mm C.struct_miqt_map = initialDataValues + initialDataValues_ret := make(map[string]qt6.QVariant, int(initialDataValues_mm.len)) + initialDataValues_Keys := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(initialDataValues_mm.keys)) + initialDataValues_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(initialDataValues_mm.values)) + for i := 0; i < int(initialDataValues_mm.len); i++ { + var initialDataValues_mapkey_ms C.struct_miqt_string = initialDataValues_Keys[i] + initialDataValues_mapkey_ret := C.GoStringN(initialDataValues_mapkey_ms.data, C.int(int64(initialDataValues_mapkey_ms.len))) + C.free(unsafe.Pointer(initialDataValues_mapkey_ms.data)) + initialDataValues_entry_Key := initialDataValues_mapkey_ret + initialDataValues_mapval_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(initialDataValues_Values[i])) + initialDataValues_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + initialDataValues_entry_Value := *initialDataValues_mapval_goptr + + initialDataValues_ret[initialDataValues_entry_Key] = initialDataValues_entry_Value + } + slotval1 := initialDataValues_ret + + virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_Setup, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_EvaluateToString(id int, ok *bool) string { + + var _ms C.struct_miqt_string = C.QScxmlNullDataModel_virtualbase_evaluateToString(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} +func (this *QScxmlNullDataModel) OnEvaluateToString(slot func(super func(id int, ok *bool) string, id int, ok *bool) string) { + ok := C.QScxmlNullDataModel_override_virtual_evaluateToString(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlNullDataModel_evaluateToString +func miqt_exec_callback_QScxmlNullDataModel_evaluateToString(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool) C.struct_miqt_string { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool) string, id int, ok *bool) string) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateToString, slotval1, slotval2) + virtualReturn_ms := C.struct_miqt_string{} + virtualReturn_ms.data = C.CString(virtualReturn) + virtualReturn_ms.len = C.size_t(len(virtualReturn)) + defer C.free(unsafe.Pointer(virtualReturn_ms.data)) + + return virtualReturn_ms + +} + +func (this *QScxmlNullDataModel) callVirtualBase_EvaluateToBool(id int, ok *bool) bool { + + return (bool)(C.QScxmlNullDataModel_virtualbase_evaluateToBool(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok)))) + +} +func (this *QScxmlNullDataModel) OnEvaluateToBool(slot func(super func(id int, ok *bool) bool, id int, ok *bool) bool) { + ok := C.QScxmlNullDataModel_override_virtual_evaluateToBool(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlNullDataModel_evaluateToBool +func miqt_exec_callback_QScxmlNullDataModel_evaluateToBool(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool) bool, id int, ok *bool) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateToBool, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_EvaluateToVariant(id int, ok *bool) *qt6.QVariant { + + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlNullDataModel_virtualbase_evaluateToVariant(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QScxmlNullDataModel) OnEvaluateToVariant(slot func(super func(id int, ok *bool) *qt6.QVariant, id int, ok *bool) *qt6.QVariant) { + ok := C.QScxmlNullDataModel_override_virtual_evaluateToVariant(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlNullDataModel_evaluateToVariant +func miqt_exec_callback_QScxmlNullDataModel_evaluateToVariant(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool) *qt6.QVariant, id int, ok *bool) *qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateToVariant, slotval1, slotval2) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_EvaluateToVoid(id int, ok *bool) { + + C.QScxmlNullDataModel_virtualbase_evaluateToVoid(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) + +} +func (this *QScxmlNullDataModel) OnEvaluateToVoid(slot func(super func(id int, ok *bool), id int, ok *bool)) { + ok := C.QScxmlNullDataModel_override_virtual_evaluateToVoid(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlNullDataModel_evaluateToVoid +func miqt_exec_callback_QScxmlNullDataModel_evaluateToVoid(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool), id int, ok *bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateToVoid, slotval1, slotval2) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_EvaluateAssignment(id int, ok *bool) { + + C.QScxmlNullDataModel_virtualbase_evaluateAssignment(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) + +} +func (this *QScxmlNullDataModel) OnEvaluateAssignment(slot func(super func(id int, ok *bool), id int, ok *bool)) { + ok := C.QScxmlNullDataModel_override_virtual_evaluateAssignment(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlNullDataModel_evaluateAssignment +func miqt_exec_callback_QScxmlNullDataModel_evaluateAssignment(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool), id int, ok *bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateAssignment, slotval1, slotval2) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_EvaluateInitialization(id int, ok *bool) { + + C.QScxmlNullDataModel_virtualbase_evaluateInitialization(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) + +} +func (this *QScxmlNullDataModel) OnEvaluateInitialization(slot func(super func(id int, ok *bool), id int, ok *bool)) { + ok := C.QScxmlNullDataModel_override_virtual_evaluateInitialization(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlNullDataModel_evaluateInitialization +func miqt_exec_callback_QScxmlNullDataModel_evaluateInitialization(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool), id int, ok *bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateInitialization, slotval1, slotval2) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_EvaluateForeach(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody) { + + C.QScxmlNullDataModel_virtualbase_evaluateForeach(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok)), body.cPointer()) + +} +func (this *QScxmlNullDataModel) OnEvaluateForeach(slot func(super func(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody), id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody)) { + ok := C.QScxmlNullDataModel_override_virtual_evaluateForeach(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlNullDataModel_evaluateForeach +func miqt_exec_callback_QScxmlNullDataModel_evaluateForeach(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool, body *C.QScxmlDataModel__ForeachLoopBody) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody), id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int)(id) + + slotval2 := (*bool)(unsafe.Pointer(ok)) + + slotval3 := newQScxmlDataModel__ForeachLoopBody(body) + + gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateForeach, slotval1, slotval2, slotval3) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_SetScxmlEvent(event *QScxmlEvent) { + + C.QScxmlNullDataModel_virtualbase_setScxmlEvent(unsafe.Pointer(this.h), event.cPointer()) + +} +func (this *QScxmlNullDataModel) OnSetScxmlEvent(slot func(super func(event *QScxmlEvent), event *QScxmlEvent)) { + ok := C.QScxmlNullDataModel_override_virtual_setScxmlEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlNullDataModel_setScxmlEvent +func miqt_exec_callback_QScxmlNullDataModel_setScxmlEvent(self *C.QScxmlNullDataModel, cb C.intptr_t, event *C.QScxmlEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QScxmlEvent), event *QScxmlEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQScxmlEvent(event) + + gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_SetScxmlEvent, slotval1) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_ScxmlProperty(name string) *qt6.QVariant { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + + _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlNullDataModel_virtualbase_scxmlProperty(unsafe.Pointer(this.h), name_ms))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr + +} +func (this *QScxmlNullDataModel) OnScxmlProperty(slot func(super func(name string) *qt6.QVariant, name string) *qt6.QVariant) { + ok := C.QScxmlNullDataModel_override_virtual_scxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlNullDataModel_scxmlProperty +func miqt_exec_callback_QScxmlNullDataModel_scxmlProperty(self *C.QScxmlNullDataModel, cb C.intptr_t, name C.struct_miqt_string) *C.QVariant { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(name string) *qt6.QVariant, name string) *qt6.QVariant) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var name_ms C.struct_miqt_string = name + name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) + C.free(unsafe.Pointer(name_ms.data)) + slotval1 := name_ret + + virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_ScxmlProperty, slotval1) + + return (*C.QVariant)(virtualReturn.UnsafePointer()) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_HasScxmlProperty(name string) bool { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + + return (bool)(C.QScxmlNullDataModel_virtualbase_hasScxmlProperty(unsafe.Pointer(this.h), name_ms)) + +} +func (this *QScxmlNullDataModel) OnHasScxmlProperty(slot func(super func(name string) bool, name string) bool) { + ok := C.QScxmlNullDataModel_override_virtual_hasScxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlNullDataModel_hasScxmlProperty +func miqt_exec_callback_QScxmlNullDataModel_hasScxmlProperty(self *C.QScxmlNullDataModel, cb C.intptr_t, name C.struct_miqt_string) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(name string) bool, name string) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var name_ms C.struct_miqt_string = name + name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) + C.free(unsafe.Pointer(name_ms.data)) + slotval1 := name_ret + + virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_HasScxmlProperty, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_SetScxmlProperty(name string, value *qt6.QVariant, context string) bool { + name_ms := C.struct_miqt_string{} + name_ms.data = C.CString(name) + name_ms.len = C.size_t(len(name)) + defer C.free(unsafe.Pointer(name_ms.data)) + context_ms := C.struct_miqt_string{} + context_ms.data = C.CString(context) + context_ms.len = C.size_t(len(context)) + defer C.free(unsafe.Pointer(context_ms.data)) + + return (bool)(C.QScxmlNullDataModel_virtualbase_setScxmlProperty(unsafe.Pointer(this.h), name_ms, (*C.QVariant)(value.UnsafePointer()), context_ms)) + +} +func (this *QScxmlNullDataModel) OnSetScxmlProperty(slot func(super func(name string, value *qt6.QVariant, context string) bool, name string, value *qt6.QVariant, context string) bool) { + ok := C.QScxmlNullDataModel_override_virtual_setScxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QScxmlNullDataModel_setScxmlProperty +func miqt_exec_callback_QScxmlNullDataModel_setScxmlProperty(self *C.QScxmlNullDataModel, cb C.intptr_t, name C.struct_miqt_string, value *C.QVariant, context C.struct_miqt_string) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(name string, value *qt6.QVariant, context string) bool, name string, value *qt6.QVariant, context string) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var name_ms C.struct_miqt_string = name + name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) + C.free(unsafe.Pointer(name_ms.data)) + slotval1 := name_ret + slotval2 := qt6.UnsafeNewQVariant(unsafe.Pointer(value)) + + var context_ms C.struct_miqt_string = context + context_ret := C.GoStringN(context_ms.data, C.int(int64(context_ms.len))) + C.free(unsafe.Pointer(context_ms.data)) + slotval3 := context_ret + + virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_SetScxmlProperty, slotval1, slotval2, slotval3) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QScxmlNullDataModel_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlNullDataModel) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_event +func miqt_exec_callback_QScxmlNullDataModel_event(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QScxmlNullDataModel_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QScxmlNullDataModel) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_eventFilter +func miqt_exec_callback_QScxmlNullDataModel_eventFilter(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QScxmlNullDataModel_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QScxmlNullDataModel) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_timerEvent +func miqt_exec_callback_QScxmlNullDataModel_timerEvent(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QScxmlNullDataModel_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QScxmlNullDataModel) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_childEvent +func miqt_exec_callback_QScxmlNullDataModel_childEvent(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QScxmlNullDataModel_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QScxmlNullDataModel) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_customEvent +func miqt_exec_callback_QScxmlNullDataModel_customEvent(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlNullDataModel_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlNullDataModel) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_connectNotify +func miqt_exec_callback_QScxmlNullDataModel_connectNotify(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QScxmlNullDataModel) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QScxmlNullDataModel_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QScxmlNullDataModel) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_disconnectNotify +func miqt_exec_callback_QScxmlNullDataModel_disconnectNotify(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QScxmlNullDataModel) Delete() { + C.QScxmlNullDataModel_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 *QScxmlNullDataModel) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlNullDataModel) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/scxml/gen_qscxmlnulldatamodel.h b/qt6/scxml/gen_qscxmlnulldatamodel.h new file mode 100644 index 000000000..007d1b23d --- /dev/null +++ b/qt6/scxml/gen_qscxmlnulldatamodel.h @@ -0,0 +1,118 @@ +#pragma once +#ifndef MIQT_QT6_SCXML_GEN_QSCXMLNULLDATAMODEL_H +#define MIQT_QT6_SCXML_GEN_QSCXMLNULLDATAMODEL_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 QScxmlDataModel; +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlDataModel__ForeachLoopBody) +typedef QScxmlDataModel::ForeachLoopBody QScxmlDataModel__ForeachLoopBody; +#else +class QScxmlDataModel__ForeachLoopBody; +#endif +class QScxmlEvent; +class QScxmlNullDataModel; +class QTimerEvent; +class QVariant; +#else +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QScxmlDataModel QScxmlDataModel; +typedef struct QScxmlDataModel__ForeachLoopBody QScxmlDataModel__ForeachLoopBody; +typedef struct QScxmlEvent QScxmlEvent; +typedef struct QScxmlNullDataModel QScxmlNullDataModel; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +#endif + +QScxmlNullDataModel* QScxmlNullDataModel_new(); +QScxmlNullDataModel* QScxmlNullDataModel_new2(QObject* parent); +void QScxmlNullDataModel_virtbase(QScxmlNullDataModel* src, QScxmlDataModel** outptr_QScxmlDataModel); +QMetaObject* QScxmlNullDataModel_metaObject(const QScxmlNullDataModel* self); +void* QScxmlNullDataModel_metacast(QScxmlNullDataModel* self, const char* param1); +struct miqt_string QScxmlNullDataModel_tr(const char* s); +bool QScxmlNullDataModel_setup(QScxmlNullDataModel* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); +struct miqt_string QScxmlNullDataModel_evaluateToString(QScxmlNullDataModel* self, int id, bool* ok); +bool QScxmlNullDataModel_evaluateToBool(QScxmlNullDataModel* self, int id, bool* ok); +QVariant* QScxmlNullDataModel_evaluateToVariant(QScxmlNullDataModel* self, int id, bool* ok); +void QScxmlNullDataModel_evaluateToVoid(QScxmlNullDataModel* self, int id, bool* ok); +void QScxmlNullDataModel_evaluateAssignment(QScxmlNullDataModel* self, int id, bool* ok); +void QScxmlNullDataModel_evaluateInitialization(QScxmlNullDataModel* self, int id, bool* ok); +void QScxmlNullDataModel_evaluateForeach(QScxmlNullDataModel* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); +void QScxmlNullDataModel_setScxmlEvent(QScxmlNullDataModel* self, QScxmlEvent* event); +QVariant* QScxmlNullDataModel_scxmlProperty(const QScxmlNullDataModel* self, struct miqt_string name); +bool QScxmlNullDataModel_hasScxmlProperty(const QScxmlNullDataModel* self, struct miqt_string name); +bool QScxmlNullDataModel_setScxmlProperty(QScxmlNullDataModel* self, struct miqt_string name, QVariant* value, struct miqt_string context); +struct miqt_string QScxmlNullDataModel_tr2(const char* s, const char* c); +struct miqt_string QScxmlNullDataModel_tr3(const char* s, const char* c, int n); + +bool QScxmlNullDataModel_override_virtual_setup(void* self, intptr_t slot); +bool QScxmlNullDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); +bool QScxmlNullDataModel_override_virtual_evaluateToString(void* self, intptr_t slot); +struct miqt_string QScxmlNullDataModel_virtualbase_evaluateToString(void* self, int id, bool* ok); +bool QScxmlNullDataModel_override_virtual_evaluateToBool(void* self, intptr_t slot); +bool QScxmlNullDataModel_virtualbase_evaluateToBool(void* self, int id, bool* ok); +bool QScxmlNullDataModel_override_virtual_evaluateToVariant(void* self, intptr_t slot); +QVariant* QScxmlNullDataModel_virtualbase_evaluateToVariant(void* self, int id, bool* ok); +bool QScxmlNullDataModel_override_virtual_evaluateToVoid(void* self, intptr_t slot); +void QScxmlNullDataModel_virtualbase_evaluateToVoid(void* self, int id, bool* ok); +bool QScxmlNullDataModel_override_virtual_evaluateAssignment(void* self, intptr_t slot); +void QScxmlNullDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok); +bool QScxmlNullDataModel_override_virtual_evaluateInitialization(void* self, intptr_t slot); +void QScxmlNullDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok); +bool QScxmlNullDataModel_override_virtual_evaluateForeach(void* self, intptr_t slot); +void QScxmlNullDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); +bool QScxmlNullDataModel_override_virtual_setScxmlEvent(void* self, intptr_t slot); +void QScxmlNullDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* event); +bool QScxmlNullDataModel_override_virtual_scxmlProperty(void* self, intptr_t slot); +QVariant* QScxmlNullDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name); +bool QScxmlNullDataModel_override_virtual_hasScxmlProperty(void* self, intptr_t slot); +bool QScxmlNullDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name); +bool QScxmlNullDataModel_override_virtual_setScxmlProperty(void* self, intptr_t slot); +bool QScxmlNullDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context); +bool QScxmlNullDataModel_override_virtual_event(void* self, intptr_t slot); +bool QScxmlNullDataModel_virtualbase_event(void* self, QEvent* event); +bool QScxmlNullDataModel_override_virtual_eventFilter(void* self, intptr_t slot); +bool QScxmlNullDataModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QScxmlNullDataModel_override_virtual_timerEvent(void* self, intptr_t slot); +void QScxmlNullDataModel_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QScxmlNullDataModel_override_virtual_childEvent(void* self, intptr_t slot); +void QScxmlNullDataModel_virtualbase_childEvent(void* self, QChildEvent* event); +bool QScxmlNullDataModel_override_virtual_customEvent(void* self, intptr_t slot); +void QScxmlNullDataModel_virtualbase_customEvent(void* self, QEvent* event); +bool QScxmlNullDataModel_override_virtual_connectNotify(void* self, intptr_t slot); +void QScxmlNullDataModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QScxmlNullDataModel_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QScxmlNullDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QScxmlNullDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QScxmlNullDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QScxmlNullDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QScxmlNullDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QScxmlNullDataModel_delete(QScxmlNullDataModel* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/scxml/gen_qscxmlstatemachine.cpp b/qt6/scxml/gen_qscxmlstatemachine.cpp new file mode 100644 index 000000000..f541a0d0b --- /dev/null +++ b/qt6/scxml/gen_qscxmlstatemachine.cpp @@ -0,0 +1,535 @@ +#include +#include +#include +#include +#include +#define WORKAROUND_INNER_CLASS_DEFINITION_QMetaObject__Connection +#include +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlCompiler__Loader +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qscxmlstatemachine.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QScxmlStateMachine_runningChanged(intptr_t, bool); +void miqt_exec_callback_QScxmlStateMachine_invokedServicesChanged(intptr_t, struct miqt_array /* of QScxmlInvokableService* */ ); +void miqt_exec_callback_QScxmlStateMachine_log(intptr_t, struct miqt_string, struct miqt_string); +void miqt_exec_callback_QScxmlStateMachine_reachedStableState(intptr_t); +void miqt_exec_callback_QScxmlStateMachine_finished(intptr_t); +void miqt_exec_callback_QScxmlStateMachine_dataModelChanged(intptr_t, QScxmlDataModel*); +void miqt_exec_callback_QScxmlStateMachine_initialValuesChanged(intptr_t, struct miqt_map /* of struct miqt_string to QVariant* */ ); +void miqt_exec_callback_QScxmlStateMachine_initializedChanged(intptr_t, bool); +void miqt_exec_callback_QScxmlStateMachine_loaderChanged(intptr_t, QScxmlCompiler__Loader*); +void miqt_exec_callback_QScxmlStateMachine_tableDataChanged(intptr_t, QScxmlTableData*); +#ifdef __cplusplus +} /* extern C */ +#endif + +void QScxmlStateMachine_virtbase(QScxmlStateMachine* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QScxmlStateMachine_metaObject(const QScxmlStateMachine* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QScxmlStateMachine_metacast(QScxmlStateMachine* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QScxmlStateMachine_tr(const char* s) { + QString _ret = QScxmlStateMachine::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; +} + +QScxmlStateMachine* QScxmlStateMachine_fromFile(struct miqt_string fileName) { + QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); + return QScxmlStateMachine::fromFile(fileName_QString); +} + +QScxmlStateMachine* QScxmlStateMachine_fromData(QIODevice* data) { + return QScxmlStateMachine::fromData(data); +} + +struct miqt_array /* of QScxmlError* */ QScxmlStateMachine_parseErrors(const QScxmlStateMachine* self) { + QList _ret = self->parseErrors(); + // Convert QList<> from C++ memory to manually-managed C memory + QScxmlError** _arr = static_cast(malloc(sizeof(QScxmlError*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QScxmlError(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +struct miqt_string QScxmlStateMachine_sessionId(const QScxmlStateMachine* self) { + QString _ret = self->sessionId(); + // 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 QScxmlStateMachine_isInvoked(const QScxmlStateMachine* self) { + return self->isInvoked(); +} + +bool QScxmlStateMachine_isInitialized(const QScxmlStateMachine* self) { + return self->isInitialized(); +} + +void QScxmlStateMachine_setDataModel(QScxmlStateMachine* self, QScxmlDataModel* model) { + self->setDataModel(model); +} + +QScxmlDataModel* QScxmlStateMachine_dataModel(const QScxmlStateMachine* self) { + return self->dataModel(); +} + +void QScxmlStateMachine_setLoader(QScxmlStateMachine* self, QScxmlCompiler__Loader* loader) { + self->setLoader(loader); +} + +QScxmlCompiler__Loader* QScxmlStateMachine_loader(const QScxmlStateMachine* self) { + return self->loader(); +} + +bool QScxmlStateMachine_isRunning(const QScxmlStateMachine* self) { + return self->isRunning(); +} + +void QScxmlStateMachine_setRunning(QScxmlStateMachine* self, bool running) { + self->setRunning(running); +} + +struct miqt_map /* of struct miqt_string to QVariant* */ QScxmlStateMachine_initialValues(QScxmlStateMachine* self) { + QVariantMap _ret = self->initialValues(); + // Convert QMap<> from C++ memory to manually-managed C memory + struct miqt_string* _karr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + QVariant** _varr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + int _ctr = 0; + for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { + QString _mapkey_ret = _itr->first; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _mapkey_b = _mapkey_ret.toUtf8(); + struct miqt_string _mapkey_ms; + _mapkey_ms.len = _mapkey_b.length(); + _mapkey_ms.data = static_cast(malloc(_mapkey_ms.len)); + memcpy(_mapkey_ms.data, _mapkey_b.data(), _mapkey_ms.len); + _karr[_ctr] = _mapkey_ms; + _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; +} + +void QScxmlStateMachine_setInitialValues(QScxmlStateMachine* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialValues) { + QVariantMap initialValues_QMap; + struct miqt_string* initialValues_karr = static_cast(initialValues.keys); + QVariant** initialValues_varr = static_cast(initialValues.values); + for(size_t i = 0; i < initialValues.len; ++i) { + QString initialValues_karr_i_QString = QString::fromUtf8(initialValues_karr[i].data, initialValues_karr[i].len); + initialValues_QMap[initialValues_karr_i_QString] = *(initialValues_varr[i]); + } + self->setInitialValues(initialValues_QMap); +} + +struct miqt_string QScxmlStateMachine_name(const QScxmlStateMachine* self) { + QString _ret = self->name(); + // 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 struct miqt_string */ QScxmlStateMachine_stateNames(const QScxmlStateMachine* self) { + QStringList _ret = self->stateNames(); + // 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; +} + +struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_activeStateNames(const QScxmlStateMachine* self) { + QStringList _ret = self->activeStateNames(); + // 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 QScxmlStateMachine_isActive(const QScxmlStateMachine* self, struct miqt_string scxmlStateName) { + QString scxmlStateName_QString = QString::fromUtf8(scxmlStateName.data, scxmlStateName.len); + return self->isActive(scxmlStateName_QString); +} + +QMetaObject__Connection* QScxmlStateMachine_connectToState(QScxmlStateMachine* self, struct miqt_string scxmlStateName, QObject* receiver, const char* method) { + QString scxmlStateName_QString = QString::fromUtf8(scxmlStateName.data, scxmlStateName.len); + return new QMetaObject::Connection(self->connectToState(scxmlStateName_QString, receiver, method)); +} + +QMetaObject__Connection* QScxmlStateMachine_connectToEvent(QScxmlStateMachine* self, struct miqt_string scxmlEventSpec, QObject* receiver, const char* method) { + QString scxmlEventSpec_QString = QString::fromUtf8(scxmlEventSpec.data, scxmlEventSpec.len); + return new QMetaObject::Connection(self->connectToEvent(scxmlEventSpec_QString, receiver, method)); +} + +void QScxmlStateMachine_submitEvent(QScxmlStateMachine* self, QScxmlEvent* event) { + self->submitEvent(event); +} + +void QScxmlStateMachine_submitEventWithEventName(QScxmlStateMachine* self, struct miqt_string eventName) { + QString eventName_QString = QString::fromUtf8(eventName.data, eventName.len); + self->submitEvent(eventName_QString); +} + +void QScxmlStateMachine_submitEvent2(QScxmlStateMachine* self, struct miqt_string eventName, QVariant* data) { + QString eventName_QString = QString::fromUtf8(eventName.data, eventName.len); + self->submitEvent(eventName_QString, *data); +} + +void QScxmlStateMachine_cancelDelayedEvent(QScxmlStateMachine* self, struct miqt_string sendId) { + QString sendId_QString = QString::fromUtf8(sendId.data, sendId.len); + self->cancelDelayedEvent(sendId_QString); +} + +bool QScxmlStateMachine_isDispatchableTarget(const QScxmlStateMachine* self, struct miqt_string target) { + QString target_QString = QString::fromUtf8(target.data, target.len); + return self->isDispatchableTarget(target_QString); +} + +struct miqt_array /* of QScxmlInvokableService* */ QScxmlStateMachine_invokedServices(const QScxmlStateMachine* self) { + QList _ret = self->invokedServices(); + // Convert QList<> from C++ memory to manually-managed C memory + QScxmlInvokableService** _arr = static_cast(malloc(sizeof(QScxmlInvokableService*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = _ret[i]; + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +QScxmlTableData* QScxmlStateMachine_tableData(const QScxmlStateMachine* self) { + return self->tableData(); +} + +void QScxmlStateMachine_setTableData(QScxmlStateMachine* self, QScxmlTableData* tableData) { + self->setTableData(tableData); +} + +void QScxmlStateMachine_runningChanged(QScxmlStateMachine* self, bool running) { + self->runningChanged(running); +} + +void QScxmlStateMachine_connect_runningChanged(QScxmlStateMachine* self, intptr_t slot) { + QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::runningChanged), self, [=](bool running) { + bool sigval1 = running; + miqt_exec_callback_QScxmlStateMachine_runningChanged(slot, sigval1); + }); +} + +void QScxmlStateMachine_invokedServicesChanged(QScxmlStateMachine* self, struct miqt_array /* of QScxmlInvokableService* */ invokedServices) { + QList invokedServices_QList; + invokedServices_QList.reserve(invokedServices.len); + QScxmlInvokableService** invokedServices_arr = static_cast(invokedServices.data); + for(size_t i = 0; i < invokedServices.len; ++i) { + invokedServices_QList.push_back(invokedServices_arr[i]); + } + self->invokedServicesChanged(invokedServices_QList); +} + +void QScxmlStateMachine_connect_invokedServicesChanged(QScxmlStateMachine* self, intptr_t slot) { + QScxmlStateMachine::connect(self, static_cast&)>(&QScxmlStateMachine::invokedServicesChanged), self, [=](const QList& invokedServices) { + const QList& invokedServices_ret = invokedServices; + // Convert QList<> from C++ memory to manually-managed C memory + QScxmlInvokableService** invokedServices_arr = static_cast(malloc(sizeof(QScxmlInvokableService*) * invokedServices_ret.length())); + for (size_t i = 0, e = invokedServices_ret.length(); i < e; ++i) { + invokedServices_arr[i] = invokedServices_ret[i]; + } + struct miqt_array invokedServices_out; + invokedServices_out.len = invokedServices_ret.length(); + invokedServices_out.data = static_cast(invokedServices_arr); + struct miqt_array /* of QScxmlInvokableService* */ sigval1 = invokedServices_out; + miqt_exec_callback_QScxmlStateMachine_invokedServicesChanged(slot, sigval1); + }); +} + +void QScxmlStateMachine_log(QScxmlStateMachine* self, struct miqt_string label, struct miqt_string msg) { + QString label_QString = QString::fromUtf8(label.data, label.len); + QString msg_QString = QString::fromUtf8(msg.data, msg.len); + self->log(label_QString, msg_QString); +} + +void QScxmlStateMachine_connect_log(QScxmlStateMachine* self, intptr_t slot) { + QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::log), self, [=](const QString& label, const QString& msg) { + const QString label_ret = label; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray label_b = label_ret.toUtf8(); + struct miqt_string label_ms; + label_ms.len = label_b.length(); + label_ms.data = static_cast(malloc(label_ms.len)); + memcpy(label_ms.data, label_b.data(), label_ms.len); + struct miqt_string sigval1 = label_ms; + const QString msg_ret = msg; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray msg_b = msg_ret.toUtf8(); + struct miqt_string msg_ms; + msg_ms.len = msg_b.length(); + msg_ms.data = static_cast(malloc(msg_ms.len)); + memcpy(msg_ms.data, msg_b.data(), msg_ms.len); + struct miqt_string sigval2 = msg_ms; + miqt_exec_callback_QScxmlStateMachine_log(slot, sigval1, sigval2); + }); +} + +void QScxmlStateMachine_reachedStableState(QScxmlStateMachine* self) { + self->reachedStableState(); +} + +void QScxmlStateMachine_connect_reachedStableState(QScxmlStateMachine* self, intptr_t slot) { + QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::reachedStableState), self, [=]() { + miqt_exec_callback_QScxmlStateMachine_reachedStableState(slot); + }); +} + +void QScxmlStateMachine_finished(QScxmlStateMachine* self) { + self->finished(); +} + +void QScxmlStateMachine_connect_finished(QScxmlStateMachine* self, intptr_t slot) { + QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::finished), self, [=]() { + miqt_exec_callback_QScxmlStateMachine_finished(slot); + }); +} + +void QScxmlStateMachine_dataModelChanged(QScxmlStateMachine* self, QScxmlDataModel* model) { + self->dataModelChanged(model); +} + +void QScxmlStateMachine_connect_dataModelChanged(QScxmlStateMachine* self, intptr_t slot) { + QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::dataModelChanged), self, [=](QScxmlDataModel* model) { + QScxmlDataModel* sigval1 = model; + miqt_exec_callback_QScxmlStateMachine_dataModelChanged(slot, sigval1); + }); +} + +void QScxmlStateMachine_initialValuesChanged(QScxmlStateMachine* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialValues) { + QVariantMap initialValues_QMap; + struct miqt_string* initialValues_karr = static_cast(initialValues.keys); + QVariant** initialValues_varr = static_cast(initialValues.values); + for(size_t i = 0; i < initialValues.len; ++i) { + QString initialValues_karr_i_QString = QString::fromUtf8(initialValues_karr[i].data, initialValues_karr[i].len); + initialValues_QMap[initialValues_karr_i_QString] = *(initialValues_varr[i]); + } + self->initialValuesChanged(initialValues_QMap); +} + +void QScxmlStateMachine_connect_initialValuesChanged(QScxmlStateMachine* self, intptr_t slot) { + QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::initialValuesChanged), self, [=](const QVariantMap& initialValues) { + const QVariantMap& initialValues_ret = initialValues; + // Convert QMap<> from C++ memory to manually-managed C memory + struct miqt_string* initialValues_karr = static_cast(malloc(sizeof(struct miqt_string) * initialValues_ret.size())); + QVariant** initialValues_varr = static_cast(malloc(sizeof(QVariant*) * initialValues_ret.size())); + int initialValues_ctr = 0; + for (auto initialValues_itr = initialValues_ret.keyValueBegin(); initialValues_itr != initialValues_ret.keyValueEnd(); ++initialValues_itr) { + QString initialValues_mapkey_ret = initialValues_itr->first; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray initialValues_mapkey_b = initialValues_mapkey_ret.toUtf8(); + struct miqt_string initialValues_mapkey_ms; + initialValues_mapkey_ms.len = initialValues_mapkey_b.length(); + initialValues_mapkey_ms.data = static_cast(malloc(initialValues_mapkey_ms.len)); + memcpy(initialValues_mapkey_ms.data, initialValues_mapkey_b.data(), initialValues_mapkey_ms.len); + initialValues_karr[initialValues_ctr] = initialValues_mapkey_ms; + initialValues_varr[initialValues_ctr] = new QVariant(initialValues_itr->second); + initialValues_ctr++; + } + struct miqt_map initialValues_out; + initialValues_out.len = initialValues_ret.size(); + initialValues_out.keys = static_cast(initialValues_karr); + initialValues_out.values = static_cast(initialValues_varr); + struct miqt_map /* of struct miqt_string to QVariant* */ sigval1 = initialValues_out; + miqt_exec_callback_QScxmlStateMachine_initialValuesChanged(slot, sigval1); + }); +} + +void QScxmlStateMachine_initializedChanged(QScxmlStateMachine* self, bool initialized) { + self->initializedChanged(initialized); +} + +void QScxmlStateMachine_connect_initializedChanged(QScxmlStateMachine* self, intptr_t slot) { + QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::initializedChanged), self, [=](bool initialized) { + bool sigval1 = initialized; + miqt_exec_callback_QScxmlStateMachine_initializedChanged(slot, sigval1); + }); +} + +void QScxmlStateMachine_loaderChanged(QScxmlStateMachine* self, QScxmlCompiler__Loader* loader) { + self->loaderChanged(loader); +} + +void QScxmlStateMachine_connect_loaderChanged(QScxmlStateMachine* self, intptr_t slot) { + QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::loaderChanged), self, [=](QScxmlCompiler::Loader* loader) { + QScxmlCompiler__Loader* sigval1 = loader; + miqt_exec_callback_QScxmlStateMachine_loaderChanged(slot, sigval1); + }); +} + +void QScxmlStateMachine_tableDataChanged(QScxmlStateMachine* self, QScxmlTableData* tableData) { + self->tableDataChanged(tableData); +} + +void QScxmlStateMachine_connect_tableDataChanged(QScxmlStateMachine* self, intptr_t slot) { + QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::tableDataChanged), self, [=](QScxmlTableData* tableData) { + QScxmlTableData* sigval1 = tableData; + miqt_exec_callback_QScxmlStateMachine_tableDataChanged(slot, sigval1); + }); +} + +void QScxmlStateMachine_start(QScxmlStateMachine* self) { + self->start(); +} + +void QScxmlStateMachine_stop(QScxmlStateMachine* self) { + self->stop(); +} + +bool QScxmlStateMachine_init(QScxmlStateMachine* self) { + return self->init(); +} + +struct miqt_string QScxmlStateMachine_tr2(const char* s, const char* c) { + QString _ret = QScxmlStateMachine::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 QScxmlStateMachine_tr3(const char* s, const char* c, int n) { + QString _ret = QScxmlStateMachine::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; +} + +QScxmlStateMachine* QScxmlStateMachine_fromData2(QIODevice* data, struct miqt_string fileName) { + QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); + return QScxmlStateMachine::fromData(data, fileName_QString); +} + +struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_stateNamesWithCompress(const QScxmlStateMachine* self, bool compress) { + QStringList _ret = self->stateNames(compress); + // 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; +} + +struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_activeStateNamesWithCompress(const QScxmlStateMachine* self, bool compress) { + QStringList _ret = self->activeStateNames(compress); + // 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; +} + +QMetaObject__Connection* QScxmlStateMachine_connectToState2(QScxmlStateMachine* self, struct miqt_string scxmlStateName, QObject* receiver, const char* method, int type) { + QString scxmlStateName_QString = QString::fromUtf8(scxmlStateName.data, scxmlStateName.len); + return new QMetaObject::Connection(self->connectToState(scxmlStateName_QString, receiver, method, static_cast(type))); +} + +QMetaObject__Connection* QScxmlStateMachine_connectToEvent2(QScxmlStateMachine* self, struct miqt_string scxmlEventSpec, QObject* receiver, const char* method, int type) { + QString scxmlEventSpec_QString = QString::fromUtf8(scxmlEventSpec.data, scxmlEventSpec.len); + return new QMetaObject::Connection(self->connectToEvent(scxmlEventSpec_QString, receiver, method, static_cast(type))); +} + +void QScxmlStateMachine_delete(QScxmlStateMachine* self) { + delete self; +} + diff --git a/qt6/scxml/gen_qscxmlstatemachine.go b/qt6/scxml/gen_qscxmlstatemachine.go new file mode 100644 index 000000000..91ff31a35 --- /dev/null +++ b/qt6/scxml/gen_qscxmlstatemachine.go @@ -0,0 +1,656 @@ +package scxml + +/* + +#include "gen_qscxmlstatemachine.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QScxmlStateMachine struct { + h *C.QScxmlStateMachine + *qt6.QObject +} + +func (this *QScxmlStateMachine) cPointer() *C.QScxmlStateMachine { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlStateMachine) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlStateMachine constructs the type using only CGO pointers. +func newQScxmlStateMachine(h *C.QScxmlStateMachine) *QScxmlStateMachine { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QScxmlStateMachine_virtbase(h, &outptr_QObject) + + return &QScxmlStateMachine{h: h, + QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQScxmlStateMachine constructs the type using only unsafe pointers. +func UnsafeNewQScxmlStateMachine(h unsafe.Pointer) *QScxmlStateMachine { + return newQScxmlStateMachine((*C.QScxmlStateMachine)(h)) +} + +func (this *QScxmlStateMachine) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlStateMachine_metaObject(this.h))) +} + +func (this *QScxmlStateMachine) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QScxmlStateMachine_metacast(this.h, param1_Cstring)) +} + +func QScxmlStateMachine_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QScxmlStateMachine_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QScxmlStateMachine_FromFile(fileName string) *QScxmlStateMachine { + 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 newQScxmlStateMachine(C.QScxmlStateMachine_fromFile(fileName_ms)) +} + +func QScxmlStateMachine_FromData(data *qt6.QIODevice) *QScxmlStateMachine { + return newQScxmlStateMachine(C.QScxmlStateMachine_fromData((*C.QIODevice)(data.UnsafePointer()))) +} + +func (this *QScxmlStateMachine) ParseErrors() []QScxmlError { + var _ma C.struct_miqt_array = C.QScxmlStateMachine_parseErrors(this.h) + _ret := make([]QScxmlError, int(_ma.len)) + _outCast := (*[0xffff]*C.QScxmlError)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := newQScxmlError(_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 *QScxmlStateMachine) SessionId() string { + var _ms C.struct_miqt_string = C.QScxmlStateMachine_sessionId(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlStateMachine) IsInvoked() bool { + return (bool)(C.QScxmlStateMachine_isInvoked(this.h)) +} + +func (this *QScxmlStateMachine) IsInitialized() bool { + return (bool)(C.QScxmlStateMachine_isInitialized(this.h)) +} + +func (this *QScxmlStateMachine) SetDataModel(model *QScxmlDataModel) { + C.QScxmlStateMachine_setDataModel(this.h, model.cPointer()) +} + +func (this *QScxmlStateMachine) DataModel() *QScxmlDataModel { + return newQScxmlDataModel(C.QScxmlStateMachine_dataModel(this.h)) +} + +func (this *QScxmlStateMachine) SetLoader(loader *QScxmlCompiler__Loader) { + C.QScxmlStateMachine_setLoader(this.h, loader.cPointer()) +} + +func (this *QScxmlStateMachine) Loader() *QScxmlCompiler__Loader { + return newQScxmlCompiler__Loader(C.QScxmlStateMachine_loader(this.h)) +} + +func (this *QScxmlStateMachine) IsRunning() bool { + return (bool)(C.QScxmlStateMachine_isRunning(this.h)) +} + +func (this *QScxmlStateMachine) SetRunning(running bool) { + C.QScxmlStateMachine_setRunning(this.h, (C.bool)(running)) +} + +func (this *QScxmlStateMachine) InitialValues() map[string]qt6.QVariant { + var _mm C.struct_miqt_map = C.QScxmlStateMachine_initialValues(this.h) + _ret := make(map[string]qt6.QVariant, int(_mm.len)) + _Keys := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_mm.keys)) + _Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(_mm.values)) + for i := 0; i < int(_mm.len); i++ { + var _mapkey_ms C.struct_miqt_string = _Keys[i] + _mapkey_ret := C.GoStringN(_mapkey_ms.data, C.int(int64(_mapkey_ms.len))) + C.free(unsafe.Pointer(_mapkey_ms.data)) + _entry_Key := _mapkey_ret + _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 *QScxmlStateMachine) SetInitialValues(initialValues map[string]qt6.QVariant) { + initialValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialValues)))) + defer C.free(unsafe.Pointer(initialValues_Keys_CArray)) + initialValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialValues)))) + defer C.free(unsafe.Pointer(initialValues_Values_CArray)) + initialValues_ctr := 0 + for initialValues_k, initialValues_v := range initialValues { + initialValues_k_ms := C.struct_miqt_string{} + initialValues_k_ms.data = C.CString(initialValues_k) + initialValues_k_ms.len = C.size_t(len(initialValues_k)) + defer C.free(unsafe.Pointer(initialValues_k_ms.data)) + initialValues_Keys_CArray[initialValues_ctr] = initialValues_k_ms + initialValues_Values_CArray[initialValues_ctr] = (*C.QVariant)(initialValues_v.UnsafePointer()) + initialValues_ctr++ + } + initialValues_mm := C.struct_miqt_map{ + len: C.size_t(len(initialValues)), + keys: unsafe.Pointer(initialValues_Keys_CArray), + values: unsafe.Pointer(initialValues_Values_CArray), + } + C.QScxmlStateMachine_setInitialValues(this.h, initialValues_mm) +} + +func (this *QScxmlStateMachine) Name() string { + var _ms C.struct_miqt_string = C.QScxmlStateMachine_name(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlStateMachine) StateNames() []string { + var _ma C.struct_miqt_array = C.QScxmlStateMachine_stateNames(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 *QScxmlStateMachine) ActiveStateNames() []string { + var _ma C.struct_miqt_array = C.QScxmlStateMachine_activeStateNames(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 *QScxmlStateMachine) IsActive(scxmlStateName string) bool { + scxmlStateName_ms := C.struct_miqt_string{} + scxmlStateName_ms.data = C.CString(scxmlStateName) + scxmlStateName_ms.len = C.size_t(len(scxmlStateName)) + defer C.free(unsafe.Pointer(scxmlStateName_ms.data)) + return (bool)(C.QScxmlStateMachine_isActive(this.h, scxmlStateName_ms)) +} + +func (this *QScxmlStateMachine) ConnectToState(scxmlStateName string, receiver *qt6.QObject, method string) *qt6.QMetaObject__Connection { + scxmlStateName_ms := C.struct_miqt_string{} + scxmlStateName_ms.data = C.CString(scxmlStateName) + scxmlStateName_ms.len = C.size_t(len(scxmlStateName)) + defer C.free(unsafe.Pointer(scxmlStateName_ms.data)) + method_Cstring := C.CString(method) + defer C.free(unsafe.Pointer(method_Cstring)) + _goptr := qt6.UnsafeNewQMetaObject__Connection(unsafe.Pointer(C.QScxmlStateMachine_connectToState(this.h, scxmlStateName_ms, (*C.QObject)(receiver.UnsafePointer()), method_Cstring))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QScxmlStateMachine) ConnectToEvent(scxmlEventSpec string, receiver *qt6.QObject, method string) *qt6.QMetaObject__Connection { + scxmlEventSpec_ms := C.struct_miqt_string{} + scxmlEventSpec_ms.data = C.CString(scxmlEventSpec) + scxmlEventSpec_ms.len = C.size_t(len(scxmlEventSpec)) + defer C.free(unsafe.Pointer(scxmlEventSpec_ms.data)) + method_Cstring := C.CString(method) + defer C.free(unsafe.Pointer(method_Cstring)) + _goptr := qt6.UnsafeNewQMetaObject__Connection(unsafe.Pointer(C.QScxmlStateMachine_connectToEvent(this.h, scxmlEventSpec_ms, (*C.QObject)(receiver.UnsafePointer()), method_Cstring))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QScxmlStateMachine) SubmitEvent(event *QScxmlEvent) { + C.QScxmlStateMachine_submitEvent(this.h, event.cPointer()) +} + +func (this *QScxmlStateMachine) SubmitEventWithEventName(eventName string) { + eventName_ms := C.struct_miqt_string{} + eventName_ms.data = C.CString(eventName) + eventName_ms.len = C.size_t(len(eventName)) + defer C.free(unsafe.Pointer(eventName_ms.data)) + C.QScxmlStateMachine_submitEventWithEventName(this.h, eventName_ms) +} + +func (this *QScxmlStateMachine) SubmitEvent2(eventName string, data *qt6.QVariant) { + eventName_ms := C.struct_miqt_string{} + eventName_ms.data = C.CString(eventName) + eventName_ms.len = C.size_t(len(eventName)) + defer C.free(unsafe.Pointer(eventName_ms.data)) + C.QScxmlStateMachine_submitEvent2(this.h, eventName_ms, (*C.QVariant)(data.UnsafePointer())) +} + +func (this *QScxmlStateMachine) CancelDelayedEvent(sendId string) { + sendId_ms := C.struct_miqt_string{} + sendId_ms.data = C.CString(sendId) + sendId_ms.len = C.size_t(len(sendId)) + defer C.free(unsafe.Pointer(sendId_ms.data)) + C.QScxmlStateMachine_cancelDelayedEvent(this.h, sendId_ms) +} + +func (this *QScxmlStateMachine) IsDispatchableTarget(target string) bool { + target_ms := C.struct_miqt_string{} + target_ms.data = C.CString(target) + target_ms.len = C.size_t(len(target)) + defer C.free(unsafe.Pointer(target_ms.data)) + return (bool)(C.QScxmlStateMachine_isDispatchableTarget(this.h, target_ms)) +} + +func (this *QScxmlStateMachine) InvokedServices() []*QScxmlInvokableService { + var _ma C.struct_miqt_array = C.QScxmlStateMachine_invokedServices(this.h) + _ret := make([]*QScxmlInvokableService, int(_ma.len)) + _outCast := (*[0xffff]*C.QScxmlInvokableService)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _ret[i] = newQScxmlInvokableService(_outCast[i]) + } + return _ret +} + +func (this *QScxmlStateMachine) TableData() *QScxmlTableData { + return newQScxmlTableData(C.QScxmlStateMachine_tableData(this.h)) +} + +func (this *QScxmlStateMachine) SetTableData(tableData *QScxmlTableData) { + C.QScxmlStateMachine_setTableData(this.h, tableData.cPointer()) +} + +func (this *QScxmlStateMachine) RunningChanged(running bool) { + C.QScxmlStateMachine_runningChanged(this.h, (C.bool)(running)) +} +func (this *QScxmlStateMachine) OnRunningChanged(slot func(running bool)) { + C.QScxmlStateMachine_connect_runningChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QScxmlStateMachine_runningChanged +func miqt_exec_callback_QScxmlStateMachine_runningChanged(cb C.intptr_t, running C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(running bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(running) + + gofunc(slotval1) +} + +func (this *QScxmlStateMachine) InvokedServicesChanged(invokedServices []*QScxmlInvokableService) { + invokedServices_CArray := (*[0xffff]*C.QScxmlInvokableService)(C.malloc(C.size_t(8 * len(invokedServices)))) + defer C.free(unsafe.Pointer(invokedServices_CArray)) + for i := range invokedServices { + invokedServices_CArray[i] = invokedServices[i].cPointer() + } + invokedServices_ma := C.struct_miqt_array{len: C.size_t(len(invokedServices)), data: unsafe.Pointer(invokedServices_CArray)} + C.QScxmlStateMachine_invokedServicesChanged(this.h, invokedServices_ma) +} +func (this *QScxmlStateMachine) OnInvokedServicesChanged(slot func(invokedServices []*QScxmlInvokableService)) { + C.QScxmlStateMachine_connect_invokedServicesChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QScxmlStateMachine_invokedServicesChanged +func miqt_exec_callback_QScxmlStateMachine_invokedServicesChanged(cb C.intptr_t, invokedServices C.struct_miqt_array) { + gofunc, ok := cgo.Handle(cb).Value().(func(invokedServices []*QScxmlInvokableService)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var invokedServices_ma C.struct_miqt_array = invokedServices + invokedServices_ret := make([]*QScxmlInvokableService, int(invokedServices_ma.len)) + invokedServices_outCast := (*[0xffff]*C.QScxmlInvokableService)(unsafe.Pointer(invokedServices_ma.data)) // hey ya + for i := 0; i < int(invokedServices_ma.len); i++ { + invokedServices_ret[i] = newQScxmlInvokableService(invokedServices_outCast[i]) + } + slotval1 := invokedServices_ret + + gofunc(slotval1) +} + +func (this *QScxmlStateMachine) Log(label string, msg string) { + label_ms := C.struct_miqt_string{} + label_ms.data = C.CString(label) + label_ms.len = C.size_t(len(label)) + defer C.free(unsafe.Pointer(label_ms.data)) + msg_ms := C.struct_miqt_string{} + msg_ms.data = C.CString(msg) + msg_ms.len = C.size_t(len(msg)) + defer C.free(unsafe.Pointer(msg_ms.data)) + C.QScxmlStateMachine_log(this.h, label_ms, msg_ms) +} +func (this *QScxmlStateMachine) OnLog(slot func(label string, msg string)) { + C.QScxmlStateMachine_connect_log(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QScxmlStateMachine_log +func miqt_exec_callback_QScxmlStateMachine_log(cb C.intptr_t, label C.struct_miqt_string, msg C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(label string, msg string)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var label_ms C.struct_miqt_string = label + label_ret := C.GoStringN(label_ms.data, C.int(int64(label_ms.len))) + C.free(unsafe.Pointer(label_ms.data)) + slotval1 := label_ret + var msg_ms C.struct_miqt_string = msg + msg_ret := C.GoStringN(msg_ms.data, C.int(int64(msg_ms.len))) + C.free(unsafe.Pointer(msg_ms.data)) + slotval2 := msg_ret + + gofunc(slotval1, slotval2) +} + +func (this *QScxmlStateMachine) ReachedStableState() { + C.QScxmlStateMachine_reachedStableState(this.h) +} +func (this *QScxmlStateMachine) OnReachedStableState(slot func()) { + C.QScxmlStateMachine_connect_reachedStableState(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QScxmlStateMachine_reachedStableState +func miqt_exec_callback_QScxmlStateMachine_reachedStableState(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 *QScxmlStateMachine) Finished() { + C.QScxmlStateMachine_finished(this.h) +} +func (this *QScxmlStateMachine) OnFinished(slot func()) { + C.QScxmlStateMachine_connect_finished(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QScxmlStateMachine_finished +func miqt_exec_callback_QScxmlStateMachine_finished(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 *QScxmlStateMachine) DataModelChanged(model *QScxmlDataModel) { + C.QScxmlStateMachine_dataModelChanged(this.h, model.cPointer()) +} +func (this *QScxmlStateMachine) OnDataModelChanged(slot func(model *QScxmlDataModel)) { + C.QScxmlStateMachine_connect_dataModelChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QScxmlStateMachine_dataModelChanged +func miqt_exec_callback_QScxmlStateMachine_dataModelChanged(cb C.intptr_t, model *C.QScxmlDataModel) { + gofunc, ok := cgo.Handle(cb).Value().(func(model *QScxmlDataModel)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQScxmlDataModel(model) + + gofunc(slotval1) +} + +func (this *QScxmlStateMachine) InitialValuesChanged(initialValues map[string]qt6.QVariant) { + initialValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialValues)))) + defer C.free(unsafe.Pointer(initialValues_Keys_CArray)) + initialValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialValues)))) + defer C.free(unsafe.Pointer(initialValues_Values_CArray)) + initialValues_ctr := 0 + for initialValues_k, initialValues_v := range initialValues { + initialValues_k_ms := C.struct_miqt_string{} + initialValues_k_ms.data = C.CString(initialValues_k) + initialValues_k_ms.len = C.size_t(len(initialValues_k)) + defer C.free(unsafe.Pointer(initialValues_k_ms.data)) + initialValues_Keys_CArray[initialValues_ctr] = initialValues_k_ms + initialValues_Values_CArray[initialValues_ctr] = (*C.QVariant)(initialValues_v.UnsafePointer()) + initialValues_ctr++ + } + initialValues_mm := C.struct_miqt_map{ + len: C.size_t(len(initialValues)), + keys: unsafe.Pointer(initialValues_Keys_CArray), + values: unsafe.Pointer(initialValues_Values_CArray), + } + C.QScxmlStateMachine_initialValuesChanged(this.h, initialValues_mm) +} +func (this *QScxmlStateMachine) OnInitialValuesChanged(slot func(initialValues map[string]qt6.QVariant)) { + C.QScxmlStateMachine_connect_initialValuesChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QScxmlStateMachine_initialValuesChanged +func miqt_exec_callback_QScxmlStateMachine_initialValuesChanged(cb C.intptr_t, initialValues C.struct_miqt_map) { + gofunc, ok := cgo.Handle(cb).Value().(func(initialValues map[string]qt6.QVariant)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var initialValues_mm C.struct_miqt_map = initialValues + initialValues_ret := make(map[string]qt6.QVariant, int(initialValues_mm.len)) + initialValues_Keys := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(initialValues_mm.keys)) + initialValues_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(initialValues_mm.values)) + for i := 0; i < int(initialValues_mm.len); i++ { + var initialValues_mapkey_ms C.struct_miqt_string = initialValues_Keys[i] + initialValues_mapkey_ret := C.GoStringN(initialValues_mapkey_ms.data, C.int(int64(initialValues_mapkey_ms.len))) + C.free(unsafe.Pointer(initialValues_mapkey_ms.data)) + initialValues_entry_Key := initialValues_mapkey_ret + initialValues_mapval_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(initialValues_Values[i])) + initialValues_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + initialValues_entry_Value := *initialValues_mapval_goptr + + initialValues_ret[initialValues_entry_Key] = initialValues_entry_Value + } + slotval1 := initialValues_ret + + gofunc(slotval1) +} + +func (this *QScxmlStateMachine) InitializedChanged(initialized bool) { + C.QScxmlStateMachine_initializedChanged(this.h, (C.bool)(initialized)) +} +func (this *QScxmlStateMachine) OnInitializedChanged(slot func(initialized bool)) { + C.QScxmlStateMachine_connect_initializedChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QScxmlStateMachine_initializedChanged +func miqt_exec_callback_QScxmlStateMachine_initializedChanged(cb C.intptr_t, initialized C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(initialized bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(initialized) + + gofunc(slotval1) +} + +func (this *QScxmlStateMachine) LoaderChanged(loader *QScxmlCompiler__Loader) { + C.QScxmlStateMachine_loaderChanged(this.h, loader.cPointer()) +} +func (this *QScxmlStateMachine) OnLoaderChanged(slot func(loader *QScxmlCompiler__Loader)) { + C.QScxmlStateMachine_connect_loaderChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QScxmlStateMachine_loaderChanged +func miqt_exec_callback_QScxmlStateMachine_loaderChanged(cb C.intptr_t, loader *C.QScxmlCompiler__Loader) { + gofunc, ok := cgo.Handle(cb).Value().(func(loader *QScxmlCompiler__Loader)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQScxmlCompiler__Loader(loader) + + gofunc(slotval1) +} + +func (this *QScxmlStateMachine) TableDataChanged(tableData *QScxmlTableData) { + C.QScxmlStateMachine_tableDataChanged(this.h, tableData.cPointer()) +} +func (this *QScxmlStateMachine) OnTableDataChanged(slot func(tableData *QScxmlTableData)) { + C.QScxmlStateMachine_connect_tableDataChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QScxmlStateMachine_tableDataChanged +func miqt_exec_callback_QScxmlStateMachine_tableDataChanged(cb C.intptr_t, tableData *C.QScxmlTableData) { + gofunc, ok := cgo.Handle(cb).Value().(func(tableData *QScxmlTableData)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQScxmlTableData(tableData) + + gofunc(slotval1) +} + +func (this *QScxmlStateMachine) Start() { + C.QScxmlStateMachine_start(this.h) +} + +func (this *QScxmlStateMachine) Stop() { + C.QScxmlStateMachine_stop(this.h) +} + +func (this *QScxmlStateMachine) Init() bool { + return (bool)(C.QScxmlStateMachine_init(this.h)) +} + +func QScxmlStateMachine_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.QScxmlStateMachine_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QScxmlStateMachine_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.QScxmlStateMachine_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 QScxmlStateMachine_FromData2(data *qt6.QIODevice, fileName string) *QScxmlStateMachine { + 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 newQScxmlStateMachine(C.QScxmlStateMachine_fromData2((*C.QIODevice)(data.UnsafePointer()), fileName_ms)) +} + +func (this *QScxmlStateMachine) StateNamesWithCompress(compress bool) []string { + var _ma C.struct_miqt_array = C.QScxmlStateMachine_stateNamesWithCompress(this.h, (C.bool)(compress)) + _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 *QScxmlStateMachine) ActiveStateNamesWithCompress(compress bool) []string { + var _ma C.struct_miqt_array = C.QScxmlStateMachine_activeStateNamesWithCompress(this.h, (C.bool)(compress)) + _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 *QScxmlStateMachine) ConnectToState2(scxmlStateName string, receiver *qt6.QObject, method string, typeVal qt6.ConnectionType) *qt6.QMetaObject__Connection { + scxmlStateName_ms := C.struct_miqt_string{} + scxmlStateName_ms.data = C.CString(scxmlStateName) + scxmlStateName_ms.len = C.size_t(len(scxmlStateName)) + defer C.free(unsafe.Pointer(scxmlStateName_ms.data)) + method_Cstring := C.CString(method) + defer C.free(unsafe.Pointer(method_Cstring)) + _goptr := qt6.UnsafeNewQMetaObject__Connection(unsafe.Pointer(C.QScxmlStateMachine_connectToState2(this.h, scxmlStateName_ms, (*C.QObject)(receiver.UnsafePointer()), method_Cstring, (C.int)(typeVal)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QScxmlStateMachine) ConnectToEvent2(scxmlEventSpec string, receiver *qt6.QObject, method string, typeVal qt6.ConnectionType) *qt6.QMetaObject__Connection { + scxmlEventSpec_ms := C.struct_miqt_string{} + scxmlEventSpec_ms.data = C.CString(scxmlEventSpec) + scxmlEventSpec_ms.len = C.size_t(len(scxmlEventSpec)) + defer C.free(unsafe.Pointer(scxmlEventSpec_ms.data)) + method_Cstring := C.CString(method) + defer C.free(unsafe.Pointer(method_Cstring)) + _goptr := qt6.UnsafeNewQMetaObject__Connection(unsafe.Pointer(C.QScxmlStateMachine_connectToEvent2(this.h, scxmlEventSpec_ms, (*C.QObject)(receiver.UnsafePointer()), method_Cstring, (C.int)(typeVal)))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +// Delete this object from C++ memory. +func (this *QScxmlStateMachine) Delete() { + C.QScxmlStateMachine_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 *QScxmlStateMachine) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlStateMachine) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/scxml/gen_qscxmlstatemachine.h b/qt6/scxml/gen_qscxmlstatemachine.h new file mode 100644 index 000000000..771c388eb --- /dev/null +++ b/qt6/scxml/gen_qscxmlstatemachine.h @@ -0,0 +1,124 @@ +#pragma once +#ifndef MIQT_QT6_SCXML_GEN_QSCXMLSTATEMACHINE_H +#define MIQT_QT6_SCXML_GEN_QSCXMLSTATEMACHINE_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QIODevice; +class QMetaMethod; +class QMetaObject; +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QMetaObject__Connection) +typedef QMetaObject::Connection QMetaObject__Connection; +#else +class QMetaObject__Connection; +#endif +class QObject; +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlCompiler__Loader) +typedef QScxmlCompiler::Loader QScxmlCompiler__Loader; +#else +class QScxmlCompiler__Loader; +#endif +class QScxmlDataModel; +class QScxmlError; +class QScxmlEvent; +class QScxmlInvokableService; +class QScxmlStateMachine; +class QScxmlTableData; +class QVariant; +#else +typedef struct QIODevice QIODevice; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QMetaObject__Connection QMetaObject__Connection; +typedef struct QObject QObject; +typedef struct QScxmlCompiler__Loader QScxmlCompiler__Loader; +typedef struct QScxmlDataModel QScxmlDataModel; +typedef struct QScxmlError QScxmlError; +typedef struct QScxmlEvent QScxmlEvent; +typedef struct QScxmlInvokableService QScxmlInvokableService; +typedef struct QScxmlStateMachine QScxmlStateMachine; +typedef struct QScxmlTableData QScxmlTableData; +typedef struct QVariant QVariant; +#endif + +void QScxmlStateMachine_virtbase(QScxmlStateMachine* src, QObject** outptr_QObject); +QMetaObject* QScxmlStateMachine_metaObject(const QScxmlStateMachine* self); +void* QScxmlStateMachine_metacast(QScxmlStateMachine* self, const char* param1); +struct miqt_string QScxmlStateMachine_tr(const char* s); +QScxmlStateMachine* QScxmlStateMachine_fromFile(struct miqt_string fileName); +QScxmlStateMachine* QScxmlStateMachine_fromData(QIODevice* data); +struct miqt_array /* of QScxmlError* */ QScxmlStateMachine_parseErrors(const QScxmlStateMachine* self); +struct miqt_string QScxmlStateMachine_sessionId(const QScxmlStateMachine* self); +bool QScxmlStateMachine_isInvoked(const QScxmlStateMachine* self); +bool QScxmlStateMachine_isInitialized(const QScxmlStateMachine* self); +void QScxmlStateMachine_setDataModel(QScxmlStateMachine* self, QScxmlDataModel* model); +QScxmlDataModel* QScxmlStateMachine_dataModel(const QScxmlStateMachine* self); +void QScxmlStateMachine_setLoader(QScxmlStateMachine* self, QScxmlCompiler__Loader* loader); +QScxmlCompiler__Loader* QScxmlStateMachine_loader(const QScxmlStateMachine* self); +bool QScxmlStateMachine_isRunning(const QScxmlStateMachine* self); +void QScxmlStateMachine_setRunning(QScxmlStateMachine* self, bool running); +struct miqt_map /* of struct miqt_string to QVariant* */ QScxmlStateMachine_initialValues(QScxmlStateMachine* self); +void QScxmlStateMachine_setInitialValues(QScxmlStateMachine* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialValues); +struct miqt_string QScxmlStateMachine_name(const QScxmlStateMachine* self); +struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_stateNames(const QScxmlStateMachine* self); +struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_activeStateNames(const QScxmlStateMachine* self); +bool QScxmlStateMachine_isActive(const QScxmlStateMachine* self, struct miqt_string scxmlStateName); +QMetaObject__Connection* QScxmlStateMachine_connectToState(QScxmlStateMachine* self, struct miqt_string scxmlStateName, QObject* receiver, const char* method); +QMetaObject__Connection* QScxmlStateMachine_connectToEvent(QScxmlStateMachine* self, struct miqt_string scxmlEventSpec, QObject* receiver, const char* method); +void QScxmlStateMachine_submitEvent(QScxmlStateMachine* self, QScxmlEvent* event); +void QScxmlStateMachine_submitEventWithEventName(QScxmlStateMachine* self, struct miqt_string eventName); +void QScxmlStateMachine_submitEvent2(QScxmlStateMachine* self, struct miqt_string eventName, QVariant* data); +void QScxmlStateMachine_cancelDelayedEvent(QScxmlStateMachine* self, struct miqt_string sendId); +bool QScxmlStateMachine_isDispatchableTarget(const QScxmlStateMachine* self, struct miqt_string target); +struct miqt_array /* of QScxmlInvokableService* */ QScxmlStateMachine_invokedServices(const QScxmlStateMachine* self); +QScxmlTableData* QScxmlStateMachine_tableData(const QScxmlStateMachine* self); +void QScxmlStateMachine_setTableData(QScxmlStateMachine* self, QScxmlTableData* tableData); +void QScxmlStateMachine_runningChanged(QScxmlStateMachine* self, bool running); +void QScxmlStateMachine_connect_runningChanged(QScxmlStateMachine* self, intptr_t slot); +void QScxmlStateMachine_invokedServicesChanged(QScxmlStateMachine* self, struct miqt_array /* of QScxmlInvokableService* */ invokedServices); +void QScxmlStateMachine_connect_invokedServicesChanged(QScxmlStateMachine* self, intptr_t slot); +void QScxmlStateMachine_log(QScxmlStateMachine* self, struct miqt_string label, struct miqt_string msg); +void QScxmlStateMachine_connect_log(QScxmlStateMachine* self, intptr_t slot); +void QScxmlStateMachine_reachedStableState(QScxmlStateMachine* self); +void QScxmlStateMachine_connect_reachedStableState(QScxmlStateMachine* self, intptr_t slot); +void QScxmlStateMachine_finished(QScxmlStateMachine* self); +void QScxmlStateMachine_connect_finished(QScxmlStateMachine* self, intptr_t slot); +void QScxmlStateMachine_dataModelChanged(QScxmlStateMachine* self, QScxmlDataModel* model); +void QScxmlStateMachine_connect_dataModelChanged(QScxmlStateMachine* self, intptr_t slot); +void QScxmlStateMachine_initialValuesChanged(QScxmlStateMachine* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialValues); +void QScxmlStateMachine_connect_initialValuesChanged(QScxmlStateMachine* self, intptr_t slot); +void QScxmlStateMachine_initializedChanged(QScxmlStateMachine* self, bool initialized); +void QScxmlStateMachine_connect_initializedChanged(QScxmlStateMachine* self, intptr_t slot); +void QScxmlStateMachine_loaderChanged(QScxmlStateMachine* self, QScxmlCompiler__Loader* loader); +void QScxmlStateMachine_connect_loaderChanged(QScxmlStateMachine* self, intptr_t slot); +void QScxmlStateMachine_tableDataChanged(QScxmlStateMachine* self, QScxmlTableData* tableData); +void QScxmlStateMachine_connect_tableDataChanged(QScxmlStateMachine* self, intptr_t slot); +void QScxmlStateMachine_start(QScxmlStateMachine* self); +void QScxmlStateMachine_stop(QScxmlStateMachine* self); +bool QScxmlStateMachine_init(QScxmlStateMachine* self); +struct miqt_string QScxmlStateMachine_tr2(const char* s, const char* c); +struct miqt_string QScxmlStateMachine_tr3(const char* s, const char* c, int n); +QScxmlStateMachine* QScxmlStateMachine_fromData2(QIODevice* data, struct miqt_string fileName); +struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_stateNamesWithCompress(const QScxmlStateMachine* self, bool compress); +struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_activeStateNamesWithCompress(const QScxmlStateMachine* self, bool compress); +QMetaObject__Connection* QScxmlStateMachine_connectToState2(QScxmlStateMachine* self, struct miqt_string scxmlStateName, QObject* receiver, const char* method, int type); +QMetaObject__Connection* QScxmlStateMachine_connectToEvent2(QScxmlStateMachine* self, struct miqt_string scxmlEventSpec, QObject* receiver, const char* method, int type); + +void QScxmlStateMachine_delete(QScxmlStateMachine* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/scxml/gen_qscxmltabledata.cpp b/qt6/scxml/gen_qscxmltabledata.cpp new file mode 100644 index 000000000..7a3167eb1 --- /dev/null +++ b/qt6/scxml/gen_qscxmltabledata.cpp @@ -0,0 +1,85 @@ +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__AssignmentInfo +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__EvaluatorInfo +#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ForeachInfo +#include +#include +#include +#include +#include +#include +#include "gen_qscxmltabledata.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +struct miqt_string QScxmlTableData_string(const QScxmlTableData* self, int id) { + QString _ret = self->string(static_cast(id)); + // 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* QScxmlTableData_instructions(const QScxmlTableData* self) { + QScxmlExecutableContent::InstructionId* _ret = self->instructions(); + return static_cast(_ret); +} + +QScxmlExecutableContent__EvaluatorInfo* QScxmlTableData_evaluatorInfo(const QScxmlTableData* self, int evaluatorId) { + return new QScxmlExecutableContent::EvaluatorInfo(self->evaluatorInfo(static_cast(evaluatorId))); +} + +QScxmlExecutableContent__AssignmentInfo* QScxmlTableData_assignmentInfo(const QScxmlTableData* self, int assignmentId) { + return new QScxmlExecutableContent::AssignmentInfo(self->assignmentInfo(static_cast(assignmentId))); +} + +QScxmlExecutableContent__ForeachInfo* QScxmlTableData_foreachInfo(const QScxmlTableData* self, int foreachId) { + return new QScxmlExecutableContent::ForeachInfo(self->foreachInfo(static_cast(foreachId))); +} + +int* QScxmlTableData_dataNames(const QScxmlTableData* self, int* count) { + QScxmlExecutableContent::StringId* _ret = self->dataNames(static_cast(count)); + return static_cast(_ret); +} + +int QScxmlTableData_initialSetup(const QScxmlTableData* self) { + QScxmlExecutableContent::ContainerId _ret = self->initialSetup(); + return static_cast(_ret); +} + +struct miqt_string QScxmlTableData_name(const QScxmlTableData* self) { + QString _ret = self->name(); + // 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; +} + +const int* QScxmlTableData_stateMachineTable(const QScxmlTableData* self) { + const qint32* _ret = self->stateMachineTable(); + return static_cast(_ret); +} + +QScxmlInvokableServiceFactory* QScxmlTableData_serviceFactory(const QScxmlTableData* self, int id) { + return self->serviceFactory(static_cast(id)); +} + +void QScxmlTableData_operatorAssign(QScxmlTableData* self, QScxmlTableData* param1) { + self->operator=(*param1); +} + +void QScxmlTableData_delete(QScxmlTableData* self) { + delete self; +} + diff --git a/qt6/scxml/gen_qscxmltabledata.go b/qt6/scxml/gen_qscxmltabledata.go new file mode 100644 index 000000000..863bf70be --- /dev/null +++ b/qt6/scxml/gen_qscxmltabledata.go @@ -0,0 +1,116 @@ +package scxml + +/* + +#include "gen_qscxmltabledata.h" +#include + +*/ +import "C" + +import ( + "runtime" + "unsafe" +) + +type QScxmlTableData struct { + h *C.QScxmlTableData +} + +func (this *QScxmlTableData) cPointer() *C.QScxmlTableData { + if this == nil { + return nil + } + return this.h +} + +func (this *QScxmlTableData) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQScxmlTableData constructs the type using only CGO pointers. +func newQScxmlTableData(h *C.QScxmlTableData) *QScxmlTableData { + if h == nil { + return nil + } + + return &QScxmlTableData{h: h} +} + +// UnsafeNewQScxmlTableData constructs the type using only unsafe pointers. +func UnsafeNewQScxmlTableData(h unsafe.Pointer) *QScxmlTableData { + return newQScxmlTableData((*C.QScxmlTableData)(h)) +} + +func (this *QScxmlTableData) String(id int) string { + var _ms C.struct_miqt_string = C.QScxmlTableData_string(this.h, (C.int)(id)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlTableData) Instructions() *int { + return (*int)(unsafe.Pointer(C.QScxmlTableData_instructions(this.h))) +} + +func (this *QScxmlTableData) EvaluatorInfo(evaluatorId int) *QScxmlExecutableContent__EvaluatorInfo { + _goptr := newQScxmlExecutableContent__EvaluatorInfo(C.QScxmlTableData_evaluatorInfo(this.h, (C.int)(evaluatorId))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QScxmlTableData) AssignmentInfo(assignmentId int) *QScxmlExecutableContent__AssignmentInfo { + _goptr := newQScxmlExecutableContent__AssignmentInfo(C.QScxmlTableData_assignmentInfo(this.h, (C.int)(assignmentId))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QScxmlTableData) ForeachInfo(foreachId int) *QScxmlExecutableContent__ForeachInfo { + _goptr := newQScxmlExecutableContent__ForeachInfo(C.QScxmlTableData_foreachInfo(this.h, (C.int)(foreachId))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QScxmlTableData) DataNames(count *int) *int { + return (*int)(unsafe.Pointer(C.QScxmlTableData_dataNames(this.h, (*C.int)(unsafe.Pointer(count))))) +} + +func (this *QScxmlTableData) InitialSetup() int { + return (int)(C.QScxmlTableData_initialSetup(this.h)) +} + +func (this *QScxmlTableData) Name() string { + var _ms C.struct_miqt_string = C.QScxmlTableData_name(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QScxmlTableData) StateMachineTable() *int { + return (*int)(unsafe.Pointer(C.QScxmlTableData_stateMachineTable(this.h))) +} + +func (this *QScxmlTableData) ServiceFactory(id int) *QScxmlInvokableServiceFactory { + return newQScxmlInvokableServiceFactory(C.QScxmlTableData_serviceFactory(this.h, (C.int)(id))) +} + +func (this *QScxmlTableData) OperatorAssign(param1 *QScxmlTableData) { + C.QScxmlTableData_operatorAssign(this.h, param1.cPointer()) +} + +// Delete this object from C++ memory. +func (this *QScxmlTableData) Delete() { + C.QScxmlTableData_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 *QScxmlTableData) GoGC() { + runtime.SetFinalizer(this, func(this *QScxmlTableData) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/scxml/gen_qscxmltabledata.h b/qt6/scxml/gen_qscxmltabledata.h new file mode 100644 index 000000000..1fd346803 --- /dev/null +++ b/qt6/scxml/gen_qscxmltabledata.h @@ -0,0 +1,61 @@ +#pragma once +#ifndef MIQT_QT6_SCXML_GEN_QSCXMLTABLEDATA_H +#define MIQT_QT6_SCXML_GEN_QSCXMLTABLEDATA_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__AssignmentInfo) +typedef QScxmlExecutableContent::AssignmentInfo QScxmlExecutableContent__AssignmentInfo; +#else +class QScxmlExecutableContent__AssignmentInfo; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__EvaluatorInfo) +typedef QScxmlExecutableContent::EvaluatorInfo QScxmlExecutableContent__EvaluatorInfo; +#else +class QScxmlExecutableContent__EvaluatorInfo; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ForeachInfo) +typedef QScxmlExecutableContent::ForeachInfo QScxmlExecutableContent__ForeachInfo; +#else +class QScxmlExecutableContent__ForeachInfo; +#endif +class QScxmlInvokableServiceFactory; +class QScxmlTableData; +#else +typedef struct QScxmlExecutableContent__AssignmentInfo QScxmlExecutableContent__AssignmentInfo; +typedef struct QScxmlExecutableContent__EvaluatorInfo QScxmlExecutableContent__EvaluatorInfo; +typedef struct QScxmlExecutableContent__ForeachInfo QScxmlExecutableContent__ForeachInfo; +typedef struct QScxmlInvokableServiceFactory QScxmlInvokableServiceFactory; +typedef struct QScxmlTableData QScxmlTableData; +#endif + +struct miqt_string QScxmlTableData_string(const QScxmlTableData* self, int id); +int* QScxmlTableData_instructions(const QScxmlTableData* self); +QScxmlExecutableContent__EvaluatorInfo* QScxmlTableData_evaluatorInfo(const QScxmlTableData* self, int evaluatorId); +QScxmlExecutableContent__AssignmentInfo* QScxmlTableData_assignmentInfo(const QScxmlTableData* self, int assignmentId); +QScxmlExecutableContent__ForeachInfo* QScxmlTableData_foreachInfo(const QScxmlTableData* self, int foreachId); +int* QScxmlTableData_dataNames(const QScxmlTableData* self, int* count); +int QScxmlTableData_initialSetup(const QScxmlTableData* self); +struct miqt_string QScxmlTableData_name(const QScxmlTableData* self); +const int* QScxmlTableData_stateMachineTable(const QScxmlTableData* self); +QScxmlInvokableServiceFactory* QScxmlTableData_serviceFactory(const QScxmlTableData* self, int id); +void QScxmlTableData_operatorAssign(QScxmlTableData* self, QScxmlTableData* param1); + +void QScxmlTableData_delete(QScxmlTableData* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/statemachine/gen_qabstractstate.cpp b/qt6/statemachine/gen_qabstractstate.cpp new file mode 100644 index 000000000..e2dd8b657 --- /dev/null +++ b/qt6/statemachine/gen_qabstractstate.cpp @@ -0,0 +1,108 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qabstractstate.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QAbstractState_activeChanged(intptr_t, bool); +void miqt_exec_callback_QAbstractState_entered(intptr_t); +void miqt_exec_callback_QAbstractState_exited(intptr_t); +#ifdef __cplusplus +} /* extern C */ +#endif + +void QAbstractState_virtbase(QAbstractState* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QAbstractState_metaObject(const QAbstractState* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QAbstractState_metacast(QAbstractState* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QAbstractState_tr(const char* s) { + QString _ret = QAbstractState::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; +} + +QState* QAbstractState_parentState(const QAbstractState* self) { + return self->parentState(); +} + +QStateMachine* QAbstractState_machine(const QAbstractState* self) { + return self->machine(); +} + +bool QAbstractState_active(const QAbstractState* self) { + return self->active(); +} + +void QAbstractState_activeChanged(QAbstractState* self, bool active) { + self->activeChanged(active); +} + +void QAbstractState_connect_activeChanged(QAbstractState* self, intptr_t slot) { + QAbstractState::connect(self, static_cast(&QAbstractState::activeChanged), self, [=](bool active) { + bool sigval1 = active; + miqt_exec_callback_QAbstractState_activeChanged(slot, sigval1); + }); +} + +struct miqt_string QAbstractState_tr2(const char* s, const char* c) { + QString _ret = QAbstractState::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 QAbstractState_tr3(const char* s, const char* c, int n) { + QString _ret = QAbstractState::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 QAbstractState_connect_entered(QAbstractState* self, intptr_t slot) { + QAbstractState::connect(self, &QAbstractState::entered, self, [=]() { + miqt_exec_callback_QAbstractState_entered(slot); + }); +} + +void QAbstractState_connect_exited(QAbstractState* self, intptr_t slot) { + QAbstractState::connect(self, &QAbstractState::exited, self, [=]() { + miqt_exec_callback_QAbstractState_exited(slot); + }); +} + +void QAbstractState_delete(QAbstractState* self) { + delete self; +} + diff --git a/qt6/statemachine/gen_qabstractstate.go b/qt6/statemachine/gen_qabstractstate.go new file mode 100644 index 000000000..9287f968a --- /dev/null +++ b/qt6/statemachine/gen_qabstractstate.go @@ -0,0 +1,166 @@ +package statemachine + +/* + +#include "gen_qabstractstate.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QAbstractState struct { + h *C.QAbstractState + *qt6.QObject +} + +func (this *QAbstractState) cPointer() *C.QAbstractState { + if this == nil { + return nil + } + return this.h +} + +func (this *QAbstractState) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQAbstractState constructs the type using only CGO pointers. +func newQAbstractState(h *C.QAbstractState) *QAbstractState { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QAbstractState_virtbase(h, &outptr_QObject) + + return &QAbstractState{h: h, + QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQAbstractState constructs the type using only unsafe pointers. +func UnsafeNewQAbstractState(h unsafe.Pointer) *QAbstractState { + return newQAbstractState((*C.QAbstractState)(h)) +} + +func (this *QAbstractState) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QAbstractState_metaObject(this.h))) +} + +func (this *QAbstractState) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QAbstractState_metacast(this.h, param1_Cstring)) +} + +func QAbstractState_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QAbstractState_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QAbstractState) ParentState() *QState { + return newQState(C.QAbstractState_parentState(this.h)) +} + +func (this *QAbstractState) Machine() *QStateMachine { + return newQStateMachine(C.QAbstractState_machine(this.h)) +} + +func (this *QAbstractState) Active() bool { + return (bool)(C.QAbstractState_active(this.h)) +} + +func (this *QAbstractState) ActiveChanged(active bool) { + C.QAbstractState_activeChanged(this.h, (C.bool)(active)) +} +func (this *QAbstractState) OnActiveChanged(slot func(active bool)) { + C.QAbstractState_connect_activeChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QAbstractState_activeChanged +func miqt_exec_callback_QAbstractState_activeChanged(cb C.intptr_t, active C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(active bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(active) + + gofunc(slotval1) +} + +func QAbstractState_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.QAbstractState_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QAbstractState_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.QAbstractState_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 *QAbstractState) OnEntered(slot func()) { + C.QAbstractState_connect_entered(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QAbstractState_entered +func miqt_exec_callback_QAbstractState_entered(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 *QAbstractState) OnExited(slot func()) { + C.QAbstractState_connect_exited(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QAbstractState_exited +func miqt_exec_callback_QAbstractState_exited(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +// Delete this object from C++ memory. +func (this *QAbstractState) Delete() { + C.QAbstractState_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 *QAbstractState) GoGC() { + runtime.SetFinalizer(this, func(this *QAbstractState) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/statemachine/gen_qabstractstate.h b/qt6/statemachine/gen_qabstractstate.h new file mode 100644 index 000000000..8dd8181b4 --- /dev/null +++ b/qt6/statemachine/gen_qabstractstate.h @@ -0,0 +1,59 @@ +#pragma once +#ifndef MIQT_QT6_STATEMACHINE_GEN_QABSTRACTSTATE_H +#define MIQT_QT6_STATEMACHINE_GEN_QABSTRACTSTATE_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractState; +class QEvent; +class QMetaMethod; +class QMetaObject; +class QObject; +class QState; +class QStateMachine; +#else +typedef struct QAbstractState QAbstractState; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QState QState; +typedef struct QStateMachine QStateMachine; +#endif + +void QAbstractState_virtbase(QAbstractState* src, QObject** outptr_QObject); +QMetaObject* QAbstractState_metaObject(const QAbstractState* self); +void* QAbstractState_metacast(QAbstractState* self, const char* param1); +struct miqt_string QAbstractState_tr(const char* s); +QState* QAbstractState_parentState(const QAbstractState* self); +QStateMachine* QAbstractState_machine(const QAbstractState* self); +bool QAbstractState_active(const QAbstractState* self); +void QAbstractState_activeChanged(QAbstractState* self, bool active); +void QAbstractState_connect_activeChanged(QAbstractState* self, intptr_t slot); +void QAbstractState_onEntry(QAbstractState* self, QEvent* event); +void QAbstractState_onExit(QAbstractState* self, QEvent* event); +bool QAbstractState_event(QAbstractState* self, QEvent* e); +struct miqt_string QAbstractState_tr2(const char* s, const char* c); +struct miqt_string QAbstractState_tr3(const char* s, const char* c, int n); + +void QAbstractState_connect_entered(QAbstractState* self, intptr_t slot); +void QAbstractState_connect_exited(QAbstractState* self, intptr_t slot); + +void QAbstractState_delete(QAbstractState* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/statemachine/gen_qabstracttransition.cpp b/qt6/statemachine/gen_qabstracttransition.cpp new file mode 100644 index 000000000..56e168dab --- /dev/null +++ b/qt6/statemachine/gen_qabstracttransition.cpp @@ -0,0 +1,509 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qabstracttransition.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QAbstractTransition_triggered(intptr_t); +void miqt_exec_callback_QAbstractTransition_targetStateChanged(intptr_t); +void miqt_exec_callback_QAbstractTransition_targetStatesChanged(intptr_t); +bool miqt_exec_callback_QAbstractTransition_eventTest(QAbstractTransition*, intptr_t, QEvent*); +void miqt_exec_callback_QAbstractTransition_onTransition(QAbstractTransition*, intptr_t, QEvent*); +bool miqt_exec_callback_QAbstractTransition_event(QAbstractTransition*, intptr_t, QEvent*); +bool miqt_exec_callback_QAbstractTransition_eventFilter(QAbstractTransition*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QAbstractTransition_timerEvent(QAbstractTransition*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QAbstractTransition_childEvent(QAbstractTransition*, intptr_t, QChildEvent*); +void miqt_exec_callback_QAbstractTransition_customEvent(QAbstractTransition*, intptr_t, QEvent*); +void miqt_exec_callback_QAbstractTransition_connectNotify(QAbstractTransition*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QAbstractTransition_disconnectNotify(QAbstractTransition*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQAbstractTransition final : public QAbstractTransition { +public: + + MiqtVirtualQAbstractTransition(): QAbstractTransition() {} + MiqtVirtualQAbstractTransition(QState* sourceState): QAbstractTransition(sourceState) {} + + virtual ~MiqtVirtualQAbstractTransition() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventTest = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventTest(QEvent* event) override { + if (handle__eventTest == 0) { + return false; // Pure virtual, there is no base we can call + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QAbstractTransition_eventTest(this, handle__eventTest, sigval1); + return callback_return_value; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__onTransition = 0; + + // Subclass to allow providing a Go implementation + virtual void onTransition(QEvent* event) override { + if (handle__onTransition == 0) { + return; // Pure virtual, there is no base we can call + } + + QEvent* sigval1 = event; + miqt_exec_callback_QAbstractTransition_onTransition(this, handle__onTransition, sigval1); + + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* e) override { + if (handle__event == 0) { + return QAbstractTransition::event(e); + } + + QEvent* sigval1 = e; + bool callback_return_value = miqt_exec_callback_QAbstractTransition_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QAbstractTransition_virtualbase_event(void* self, QEvent* e); + + // 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 QAbstractTransition::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QAbstractTransition_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QAbstractTransition_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) { + QAbstractTransition::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QAbstractTransition_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QAbstractTransition_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) { + QAbstractTransition::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QAbstractTransition_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QAbstractTransition_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) { + QAbstractTransition::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QAbstractTransition_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QAbstractTransition_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) { + QAbstractTransition::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QAbstractTransition_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QAbstractTransition_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) { + QAbstractTransition::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QAbstractTransition_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QAbstractTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QAbstractTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QAbstractTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QAbstractTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QAbstractTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QAbstractTransition* QAbstractTransition_new() { + return new (std::nothrow) MiqtVirtualQAbstractTransition(); +} + +QAbstractTransition* QAbstractTransition_new2(QState* sourceState) { + return new (std::nothrow) MiqtVirtualQAbstractTransition(sourceState); +} + +void QAbstractTransition_virtbase(QAbstractTransition* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QAbstractTransition_metaObject(const QAbstractTransition* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QAbstractTransition_metacast(QAbstractTransition* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QAbstractTransition_tr(const char* s) { + QString _ret = QAbstractTransition::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; +} + +QState* QAbstractTransition_sourceState(const QAbstractTransition* self) { + return self->sourceState(); +} + +QAbstractState* QAbstractTransition_targetState(const QAbstractTransition* self) { + return self->targetState(); +} + +void QAbstractTransition_setTargetState(QAbstractTransition* self, QAbstractState* target) { + self->setTargetState(target); +} + +struct miqt_array /* of QAbstractState* */ QAbstractTransition_targetStates(const QAbstractTransition* self) { + QList _ret = self->targetStates(); + // Convert QList<> from C++ memory to manually-managed C memory + QAbstractState** _arr = static_cast(malloc(sizeof(QAbstractState*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = _ret[i]; + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +void QAbstractTransition_setTargetStates(QAbstractTransition* self, struct miqt_array /* of QAbstractState* */ targets) { + QList targets_QList; + targets_QList.reserve(targets.len); + QAbstractState** targets_arr = static_cast(targets.data); + for(size_t i = 0; i < targets.len; ++i) { + targets_QList.push_back(targets_arr[i]); + } + self->setTargetStates(targets_QList); +} + +int QAbstractTransition_transitionType(const QAbstractTransition* self) { + QAbstractTransition::TransitionType _ret = self->transitionType(); + return static_cast(_ret); +} + +void QAbstractTransition_setTransitionType(QAbstractTransition* self, int type) { + self->setTransitionType(static_cast(type)); +} + +QStateMachine* QAbstractTransition_machine(const QAbstractTransition* self) { + return self->machine(); +} + +void QAbstractTransition_addAnimation(QAbstractTransition* self, QAbstractAnimation* animation) { + self->addAnimation(animation); +} + +void QAbstractTransition_removeAnimation(QAbstractTransition* self, QAbstractAnimation* animation) { + self->removeAnimation(animation); +} + +struct miqt_array /* of QAbstractAnimation* */ QAbstractTransition_animations(const QAbstractTransition* self) { + QList _ret = self->animations(); + // Convert QList<> from C++ memory to manually-managed C memory + QAbstractAnimation** _arr = static_cast(malloc(sizeof(QAbstractAnimation*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = _ret[i]; + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +struct miqt_string QAbstractTransition_tr2(const char* s, const char* c) { + QString _ret = QAbstractTransition::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 QAbstractTransition_tr3(const char* s, const char* c, int n) { + QString _ret = QAbstractTransition::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 QAbstractTransition_override_virtual_eventTest(void* self, intptr_t slot) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventTest = slot; + return true; +} + +bool QAbstractTransition_override_virtual_onTransition(void* self, intptr_t slot) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onTransition = slot; + return true; +} + +bool QAbstractTransition_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QAbstractTransition_virtualbase_event(void* self, QEvent* e) { + return static_cast(self)->QAbstractTransition::event(e); +} + +bool QAbstractTransition_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QAbstractTransition_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QAbstractTransition::eventFilter(watched, event); +} + +bool QAbstractTransition_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QAbstractTransition_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QAbstractTransition::timerEvent(event); +} + +bool QAbstractTransition_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QAbstractTransition_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QAbstractTransition::childEvent(event); +} + +bool QAbstractTransition_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QAbstractTransition_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QAbstractTransition::customEvent(event); +} + +bool QAbstractTransition_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QAbstractTransition_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QAbstractTransition::connectNotify(*signal); +} + +bool QAbstractTransition_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QAbstractTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QAbstractTransition::disconnectNotify(*signal); +} + +QObject* QAbstractTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QAbstractTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QAbstractTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QAbstractTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQAbstractTransition* self_cast = dynamic_cast( (QAbstractTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QAbstractTransition_connect_triggered(QAbstractTransition* self, intptr_t slot) { + QAbstractTransition::connect(self, &QAbstractTransition::triggered, self, [=]() { + miqt_exec_callback_QAbstractTransition_triggered(slot); + }); +} + +void QAbstractTransition_connect_targetStateChanged(QAbstractTransition* self, intptr_t slot) { + QAbstractTransition::connect(self, &QAbstractTransition::targetStateChanged, self, [=]() { + miqt_exec_callback_QAbstractTransition_targetStateChanged(slot); + }); +} + +void QAbstractTransition_connect_targetStatesChanged(QAbstractTransition* self, intptr_t slot) { + QAbstractTransition::connect(self, &QAbstractTransition::targetStatesChanged, self, [=]() { + miqt_exec_callback_QAbstractTransition_targetStatesChanged(slot); + }); +} + +void QAbstractTransition_delete(QAbstractTransition* self) { + delete self; +} + diff --git a/qt6/statemachine/gen_qabstracttransition.go b/qt6/statemachine/gen_qabstracttransition.go new file mode 100644 index 000000000..b464749a8 --- /dev/null +++ b/qt6/statemachine/gen_qabstracttransition.go @@ -0,0 +1,517 @@ +package statemachine + +/* + +#include "gen_qabstracttransition.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QAbstractTransition__TransitionType int + +const ( + QAbstractTransition__ExternalTransition QAbstractTransition__TransitionType = 0 + QAbstractTransition__InternalTransition QAbstractTransition__TransitionType = 1 +) + +type QAbstractTransition struct { + h *C.QAbstractTransition + *qt6.QObject +} + +func (this *QAbstractTransition) cPointer() *C.QAbstractTransition { + if this == nil { + return nil + } + return this.h +} + +func (this *QAbstractTransition) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQAbstractTransition constructs the type using only CGO pointers. +func newQAbstractTransition(h *C.QAbstractTransition) *QAbstractTransition { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QAbstractTransition_virtbase(h, &outptr_QObject) + + return &QAbstractTransition{h: h, + QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQAbstractTransition constructs the type using only unsafe pointers. +func UnsafeNewQAbstractTransition(h unsafe.Pointer) *QAbstractTransition { + return newQAbstractTransition((*C.QAbstractTransition)(h)) +} + +// NewQAbstractTransition constructs a new QAbstractTransition object. +func NewQAbstractTransition() *QAbstractTransition { + + return newQAbstractTransition(C.QAbstractTransition_new()) +} + +// NewQAbstractTransition2 constructs a new QAbstractTransition object. +func NewQAbstractTransition2(sourceState *QState) *QAbstractTransition { + + return newQAbstractTransition(C.QAbstractTransition_new2(sourceState.cPointer())) +} + +func (this *QAbstractTransition) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QAbstractTransition_metaObject(this.h))) +} + +func (this *QAbstractTransition) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QAbstractTransition_metacast(this.h, param1_Cstring)) +} + +func QAbstractTransition_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QAbstractTransition_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QAbstractTransition) SourceState() *QState { + return newQState(C.QAbstractTransition_sourceState(this.h)) +} + +func (this *QAbstractTransition) TargetState() *QAbstractState { + return newQAbstractState(C.QAbstractTransition_targetState(this.h)) +} + +func (this *QAbstractTransition) SetTargetState(target *QAbstractState) { + C.QAbstractTransition_setTargetState(this.h, target.cPointer()) +} + +func (this *QAbstractTransition) TargetStates() []*QAbstractState { + var _ma C.struct_miqt_array = C.QAbstractTransition_targetStates(this.h) + _ret := make([]*QAbstractState, int(_ma.len)) + _outCast := (*[0xffff]*C.QAbstractState)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _ret[i] = newQAbstractState(_outCast[i]) + } + return _ret +} + +func (this *QAbstractTransition) SetTargetStates(targets []*QAbstractState) { + targets_CArray := (*[0xffff]*C.QAbstractState)(C.malloc(C.size_t(8 * len(targets)))) + defer C.free(unsafe.Pointer(targets_CArray)) + for i := range targets { + targets_CArray[i] = targets[i].cPointer() + } + targets_ma := C.struct_miqt_array{len: C.size_t(len(targets)), data: unsafe.Pointer(targets_CArray)} + C.QAbstractTransition_setTargetStates(this.h, targets_ma) +} + +func (this *QAbstractTransition) TransitionType() QAbstractTransition__TransitionType { + return (QAbstractTransition__TransitionType)(C.QAbstractTransition_transitionType(this.h)) +} + +func (this *QAbstractTransition) SetTransitionType(typeVal QAbstractTransition__TransitionType) { + C.QAbstractTransition_setTransitionType(this.h, (C.int)(typeVal)) +} + +func (this *QAbstractTransition) Machine() *QStateMachine { + return newQStateMachine(C.QAbstractTransition_machine(this.h)) +} + +func (this *QAbstractTransition) AddAnimation(animation *qt6.QAbstractAnimation) { + C.QAbstractTransition_addAnimation(this.h, (*C.QAbstractAnimation)(animation.UnsafePointer())) +} + +func (this *QAbstractTransition) RemoveAnimation(animation *qt6.QAbstractAnimation) { + C.QAbstractTransition_removeAnimation(this.h, (*C.QAbstractAnimation)(animation.UnsafePointer())) +} + +func (this *QAbstractTransition) Animations() []*qt6.QAbstractAnimation { + var _ma C.struct_miqt_array = C.QAbstractTransition_animations(this.h) + _ret := make([]*qt6.QAbstractAnimation, int(_ma.len)) + _outCast := (*[0xffff]*C.QAbstractAnimation)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _ret[i] = qt6.UnsafeNewQAbstractAnimation(unsafe.Pointer(_outCast[i])) + } + return _ret +} + +func QAbstractTransition_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.QAbstractTransition_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QAbstractTransition_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.QAbstractTransition_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 +} + +// Sender can only be called from a QAbstractTransition that was directly constructed. +func (this *QAbstractTransition) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QAbstractTransition_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 QAbstractTransition that was directly constructed. +func (this *QAbstractTransition) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QAbstractTransition_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 QAbstractTransition that was directly constructed. +func (this *QAbstractTransition) 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.QAbstractTransition_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 QAbstractTransition that was directly constructed. +func (this *QAbstractTransition) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QAbstractTransition_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 *QAbstractTransition) OnEventTest(slot func(event *qt6.QEvent) bool) { + ok := C.QAbstractTransition_override_virtual_eventTest(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QAbstractTransition_eventTest +func miqt_exec_callback_QAbstractTransition_eventTest(self *C.QAbstractTransition, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(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(slotval1) + + return (C.bool)(virtualReturn) + +} +func (this *QAbstractTransition) OnOnTransition(slot func(event *qt6.QEvent)) { + ok := C.QAbstractTransition_override_virtual_onTransition(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QAbstractTransition_onTransition +func miqt_exec_callback_QAbstractTransition_onTransition(self *C.QAbstractTransition, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(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(slotval1) + +} + +func (this *QAbstractTransition) callVirtualBase_Event(e *qt6.QEvent) bool { + + return (bool)(C.QAbstractTransition_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(e.UnsafePointer()))) + +} +func (this *QAbstractTransition) OnEvent(slot func(super func(e *qt6.QEvent) bool, e *qt6.QEvent) bool) { + ok := C.QAbstractTransition_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_QAbstractTransition_event +func miqt_exec_callback_QAbstractTransition_event(self *C.QAbstractTransition, cb C.intptr_t, e *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(e *qt6.QEvent) bool, e *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(e)) + + virtualReturn := gofunc((&QAbstractTransition{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QAbstractTransition) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QAbstractTransition_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QAbstractTransition) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QAbstractTransition_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_QAbstractTransition_eventFilter +func miqt_exec_callback_QAbstractTransition_eventFilter(self *C.QAbstractTransition, 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((&QAbstractTransition{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QAbstractTransition) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QAbstractTransition_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QAbstractTransition) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QAbstractTransition_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_QAbstractTransition_timerEvent +func miqt_exec_callback_QAbstractTransition_timerEvent(self *C.QAbstractTransition, 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((&QAbstractTransition{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QAbstractTransition) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QAbstractTransition_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QAbstractTransition) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QAbstractTransition_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_QAbstractTransition_childEvent +func miqt_exec_callback_QAbstractTransition_childEvent(self *C.QAbstractTransition, 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((&QAbstractTransition{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QAbstractTransition) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QAbstractTransition_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QAbstractTransition) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QAbstractTransition_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_QAbstractTransition_customEvent +func miqt_exec_callback_QAbstractTransition_customEvent(self *C.QAbstractTransition, 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((&QAbstractTransition{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QAbstractTransition) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QAbstractTransition_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QAbstractTransition) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QAbstractTransition_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_QAbstractTransition_connectNotify +func miqt_exec_callback_QAbstractTransition_connectNotify(self *C.QAbstractTransition, 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((&QAbstractTransition{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QAbstractTransition) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QAbstractTransition_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QAbstractTransition) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QAbstractTransition_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_QAbstractTransition_disconnectNotify +func miqt_exec_callback_QAbstractTransition_disconnectNotify(self *C.QAbstractTransition, 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((&QAbstractTransition{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} +func (this *QAbstractTransition) OnTriggered(slot func()) { + C.QAbstractTransition_connect_triggered(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QAbstractTransition_triggered +func miqt_exec_callback_QAbstractTransition_triggered(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 *QAbstractTransition) OnTargetStateChanged(slot func()) { + C.QAbstractTransition_connect_targetStateChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QAbstractTransition_targetStateChanged +func miqt_exec_callback_QAbstractTransition_targetStateChanged(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 *QAbstractTransition) OnTargetStatesChanged(slot func()) { + C.QAbstractTransition_connect_targetStatesChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QAbstractTransition_targetStatesChanged +func miqt_exec_callback_QAbstractTransition_targetStatesChanged(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +// Delete this object from C++ memory. +func (this *QAbstractTransition) Delete() { + C.QAbstractTransition_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 *QAbstractTransition) GoGC() { + runtime.SetFinalizer(this, func(this *QAbstractTransition) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/statemachine/gen_qabstracttransition.h b/qt6/statemachine/gen_qabstracttransition.h new file mode 100644 index 000000000..77f958acd --- /dev/null +++ b/qt6/statemachine/gen_qabstracttransition.h @@ -0,0 +1,100 @@ +#pragma once +#ifndef MIQT_QT6_STATEMACHINE_GEN_QABSTRACTTRANSITION_H +#define MIQT_QT6_STATEMACHINE_GEN_QABSTRACTTRANSITION_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractAnimation; +class QAbstractState; +class QAbstractTransition; +class QChildEvent; +class QEvent; +class QMetaMethod; +class QMetaObject; +class QObject; +class QState; +class QStateMachine; +class QTimerEvent; +#else +typedef struct QAbstractAnimation QAbstractAnimation; +typedef struct QAbstractState QAbstractState; +typedef struct QAbstractTransition QAbstractTransition; +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QState QState; +typedef struct QStateMachine QStateMachine; +typedef struct QTimerEvent QTimerEvent; +#endif + +QAbstractTransition* QAbstractTransition_new(); +QAbstractTransition* QAbstractTransition_new2(QState* sourceState); +void QAbstractTransition_virtbase(QAbstractTransition* src, QObject** outptr_QObject); +QMetaObject* QAbstractTransition_metaObject(const QAbstractTransition* self); +void* QAbstractTransition_metacast(QAbstractTransition* self, const char* param1); +struct miqt_string QAbstractTransition_tr(const char* s); +QState* QAbstractTransition_sourceState(const QAbstractTransition* self); +QAbstractState* QAbstractTransition_targetState(const QAbstractTransition* self); +void QAbstractTransition_setTargetState(QAbstractTransition* self, QAbstractState* target); +struct miqt_array /* of QAbstractState* */ QAbstractTransition_targetStates(const QAbstractTransition* self); +void QAbstractTransition_setTargetStates(QAbstractTransition* self, struct miqt_array /* of QAbstractState* */ targets); +int QAbstractTransition_transitionType(const QAbstractTransition* self); +void QAbstractTransition_setTransitionType(QAbstractTransition* self, int type); +QStateMachine* QAbstractTransition_machine(const QAbstractTransition* self); +void QAbstractTransition_addAnimation(QAbstractTransition* self, QAbstractAnimation* animation); +void QAbstractTransition_removeAnimation(QAbstractTransition* self, QAbstractAnimation* animation); +struct miqt_array /* of QAbstractAnimation* */ QAbstractTransition_animations(const QAbstractTransition* self); +bool QAbstractTransition_eventTest(QAbstractTransition* self, QEvent* event); +void QAbstractTransition_onTransition(QAbstractTransition* self, QEvent* event); +bool QAbstractTransition_event(QAbstractTransition* self, QEvent* e); +struct miqt_string QAbstractTransition_tr2(const char* s, const char* c); +struct miqt_string QAbstractTransition_tr3(const char* s, const char* c, int n); + +bool QAbstractTransition_override_virtual_eventTest(void* self, intptr_t slot); +bool QAbstractTransition_virtualbase_eventTest(void* self, QEvent* event); +bool QAbstractTransition_override_virtual_onTransition(void* self, intptr_t slot); +void QAbstractTransition_virtualbase_onTransition(void* self, QEvent* event); +bool QAbstractTransition_override_virtual_event(void* self, intptr_t slot); +bool QAbstractTransition_virtualbase_event(void* self, QEvent* e); +bool QAbstractTransition_override_virtual_eventFilter(void* self, intptr_t slot); +bool QAbstractTransition_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QAbstractTransition_override_virtual_timerEvent(void* self, intptr_t slot); +void QAbstractTransition_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QAbstractTransition_override_virtual_childEvent(void* self, intptr_t slot); +void QAbstractTransition_virtualbase_childEvent(void* self, QChildEvent* event); +bool QAbstractTransition_override_virtual_customEvent(void* self, intptr_t slot); +void QAbstractTransition_virtualbase_customEvent(void* self, QEvent* event); +bool QAbstractTransition_override_virtual_connectNotify(void* self, intptr_t slot); +void QAbstractTransition_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QAbstractTransition_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QAbstractTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QAbstractTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QAbstractTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QAbstractTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QAbstractTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QAbstractTransition_connect_triggered(QAbstractTransition* self, intptr_t slot); +void QAbstractTransition_connect_targetStateChanged(QAbstractTransition* self, intptr_t slot); +void QAbstractTransition_connect_targetStatesChanged(QAbstractTransition* self, intptr_t slot); + +void QAbstractTransition_delete(QAbstractTransition* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/statemachine/gen_qeventtransition.cpp b/qt6/statemachine/gen_qeventtransition.cpp new file mode 100644 index 000000000..7a09e246c --- /dev/null +++ b/qt6/statemachine/gen_qeventtransition.cpp @@ -0,0 +1,456 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qeventtransition.h" + +#ifdef __cplusplus +extern "C" { +#endif + +bool miqt_exec_callback_QEventTransition_eventTest(QEventTransition*, intptr_t, QEvent*); +void miqt_exec_callback_QEventTransition_onTransition(QEventTransition*, intptr_t, QEvent*); +bool miqt_exec_callback_QEventTransition_event(QEventTransition*, intptr_t, QEvent*); +bool miqt_exec_callback_QEventTransition_eventFilter(QEventTransition*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QEventTransition_timerEvent(QEventTransition*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QEventTransition_childEvent(QEventTransition*, intptr_t, QChildEvent*); +void miqt_exec_callback_QEventTransition_customEvent(QEventTransition*, intptr_t, QEvent*); +void miqt_exec_callback_QEventTransition_connectNotify(QEventTransition*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QEventTransition_disconnectNotify(QEventTransition*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQEventTransition final : public QEventTransition { +public: + + MiqtVirtualQEventTransition(): QEventTransition() {} + MiqtVirtualQEventTransition(QObject* object, QEvent::Type type): QEventTransition(object, type) {} + MiqtVirtualQEventTransition(QState* sourceState): QEventTransition(sourceState) {} + MiqtVirtualQEventTransition(QObject* object, QEvent::Type type, QState* sourceState): QEventTransition(object, type, sourceState) {} + + virtual ~MiqtVirtualQEventTransition() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventTest = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventTest(QEvent* event) override { + if (handle__eventTest == 0) { + return QEventTransition::eventTest(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QEventTransition_eventTest(this, handle__eventTest, sigval1); + return callback_return_value; + } + + friend bool QEventTransition_virtualbase_eventTest(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__onTransition = 0; + + // Subclass to allow providing a Go implementation + virtual void onTransition(QEvent* event) override { + if (handle__onTransition == 0) { + QEventTransition::onTransition(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QEventTransition_onTransition(this, handle__onTransition, sigval1); + + } + + friend void QEventTransition_virtualbase_onTransition(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* e) override { + if (handle__event == 0) { + return QEventTransition::event(e); + } + + QEvent* sigval1 = e; + bool callback_return_value = miqt_exec_callback_QEventTransition_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QEventTransition_virtualbase_event(void* self, QEvent* e); + + // 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 QEventTransition::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QEventTransition_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QEventTransition_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) { + QEventTransition::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QEventTransition_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QEventTransition_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) { + QEventTransition::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QEventTransition_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QEventTransition_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) { + QEventTransition::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QEventTransition_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QEventTransition_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) { + QEventTransition::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QEventTransition_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QEventTransition_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) { + QEventTransition::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QEventTransition_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QEventTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QEventTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QEventTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QEventTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QEventTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QEventTransition* QEventTransition_new() { + return new (std::nothrow) MiqtVirtualQEventTransition(); +} + +QEventTransition* QEventTransition_new2(QObject* object, int type) { + return new (std::nothrow) MiqtVirtualQEventTransition(object, static_cast(type)); +} + +QEventTransition* QEventTransition_new3(QState* sourceState) { + return new (std::nothrow) MiqtVirtualQEventTransition(sourceState); +} + +QEventTransition* QEventTransition_new4(QObject* object, int type, QState* sourceState) { + return new (std::nothrow) MiqtVirtualQEventTransition(object, static_cast(type), sourceState); +} + +void QEventTransition_virtbase(QEventTransition* src, QAbstractTransition** outptr_QAbstractTransition) { + *outptr_QAbstractTransition = static_cast(src); +} + +QMetaObject* QEventTransition_metaObject(const QEventTransition* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QEventTransition_metacast(QEventTransition* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QEventTransition_tr(const char* s) { + QString _ret = QEventTransition::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; +} + +QObject* QEventTransition_eventSource(const QEventTransition* self) { + return self->eventSource(); +} + +void QEventTransition_setEventSource(QEventTransition* self, QObject* object) { + self->setEventSource(object); +} + +int QEventTransition_eventType(const QEventTransition* self) { + QEvent::Type _ret = self->eventType(); + return static_cast(_ret); +} + +void QEventTransition_setEventType(QEventTransition* self, int type) { + self->setEventType(static_cast(type)); +} + +struct miqt_string QEventTransition_tr2(const char* s, const char* c) { + QString _ret = QEventTransition::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 QEventTransition_tr3(const char* s, const char* c, int n) { + QString _ret = QEventTransition::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 QEventTransition_override_virtual_eventTest(void* self, intptr_t slot) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventTest = slot; + return true; +} + +bool QEventTransition_virtualbase_eventTest(void* self, QEvent* event) { + return static_cast(self)->QEventTransition::eventTest(event); +} + +bool QEventTransition_override_virtual_onTransition(void* self, intptr_t slot) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onTransition = slot; + return true; +} + +void QEventTransition_virtualbase_onTransition(void* self, QEvent* event) { + static_cast(self)->QEventTransition::onTransition(event); +} + +bool QEventTransition_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QEventTransition_virtualbase_event(void* self, QEvent* e) { + return static_cast(self)->QEventTransition::event(e); +} + +bool QEventTransition_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QEventTransition_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QEventTransition::eventFilter(watched, event); +} + +bool QEventTransition_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QEventTransition_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QEventTransition::timerEvent(event); +} + +bool QEventTransition_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QEventTransition_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QEventTransition::childEvent(event); +} + +bool QEventTransition_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QEventTransition_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QEventTransition::customEvent(event); +} + +bool QEventTransition_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QEventTransition_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QEventTransition::connectNotify(*signal); +} + +bool QEventTransition_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QEventTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QEventTransition::disconnectNotify(*signal); +} + +QObject* QEventTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QEventTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QEventTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QEventTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQEventTransition* self_cast = dynamic_cast( (QEventTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QEventTransition_delete(QEventTransition* self) { + delete self; +} + diff --git a/qt6/statemachine/gen_qeventtransition.go b/qt6/statemachine/gen_qeventtransition.go new file mode 100644 index 000000000..79c064221 --- /dev/null +++ b/qt6/statemachine/gen_qeventtransition.go @@ -0,0 +1,447 @@ +package statemachine + +/* + +#include "gen_qeventtransition.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QEventTransition struct { + h *C.QEventTransition + *QAbstractTransition +} + +func (this *QEventTransition) cPointer() *C.QEventTransition { + if this == nil { + return nil + } + return this.h +} + +func (this *QEventTransition) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQEventTransition constructs the type using only CGO pointers. +func newQEventTransition(h *C.QEventTransition) *QEventTransition { + if h == nil { + return nil + } + var outptr_QAbstractTransition *C.QAbstractTransition = nil + C.QEventTransition_virtbase(h, &outptr_QAbstractTransition) + + return &QEventTransition{h: h, + QAbstractTransition: newQAbstractTransition(outptr_QAbstractTransition)} +} + +// UnsafeNewQEventTransition constructs the type using only unsafe pointers. +func UnsafeNewQEventTransition(h unsafe.Pointer) *QEventTransition { + return newQEventTransition((*C.QEventTransition)(h)) +} + +// NewQEventTransition constructs a new QEventTransition object. +func NewQEventTransition() *QEventTransition { + + return newQEventTransition(C.QEventTransition_new()) +} + +// NewQEventTransition2 constructs a new QEventTransition object. +func NewQEventTransition2(object *qt6.QObject, typeVal qt6.QEvent__Type) *QEventTransition { + + return newQEventTransition(C.QEventTransition_new2((*C.QObject)(object.UnsafePointer()), (C.int)(typeVal))) +} + +// NewQEventTransition3 constructs a new QEventTransition object. +func NewQEventTransition3(sourceState *QState) *QEventTransition { + + return newQEventTransition(C.QEventTransition_new3(sourceState.cPointer())) +} + +// NewQEventTransition4 constructs a new QEventTransition object. +func NewQEventTransition4(object *qt6.QObject, typeVal qt6.QEvent__Type, sourceState *QState) *QEventTransition { + + return newQEventTransition(C.QEventTransition_new4((*C.QObject)(object.UnsafePointer()), (C.int)(typeVal), sourceState.cPointer())) +} + +func (this *QEventTransition) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QEventTransition_metaObject(this.h))) +} + +func (this *QEventTransition) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QEventTransition_metacast(this.h, param1_Cstring)) +} + +func QEventTransition_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QEventTransition_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QEventTransition) EventSource() *qt6.QObject { + return qt6.UnsafeNewQObject(unsafe.Pointer(C.QEventTransition_eventSource(this.h))) +} + +func (this *QEventTransition) SetEventSource(object *qt6.QObject) { + C.QEventTransition_setEventSource(this.h, (*C.QObject)(object.UnsafePointer())) +} + +func (this *QEventTransition) EventType() qt6.QEvent__Type { + return (qt6.QEvent__Type)(C.QEventTransition_eventType(this.h)) +} + +func (this *QEventTransition) SetEventType(typeVal qt6.QEvent__Type) { + C.QEventTransition_setEventType(this.h, (C.int)(typeVal)) +} + +func QEventTransition_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.QEventTransition_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QEventTransition_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.QEventTransition_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 +} + +// Sender can only be called from a QEventTransition that was directly constructed. +func (this *QEventTransition) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QEventTransition_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 QEventTransition that was directly constructed. +func (this *QEventTransition) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QEventTransition_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 QEventTransition that was directly constructed. +func (this *QEventTransition) 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.QEventTransition_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 QEventTransition that was directly constructed. +func (this *QEventTransition) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QEventTransition_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 *QEventTransition) callVirtualBase_EventTest(event *qt6.QEvent) bool { + + return (bool)(C.QEventTransition_virtualbase_eventTest(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QEventTransition) OnEventTest(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QEventTransition_override_virtual_eventTest(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QEventTransition_eventTest +func miqt_exec_callback_QEventTransition_eventTest(self *C.QEventTransition, 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((&QEventTransition{h: self}).callVirtualBase_EventTest, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QEventTransition) callVirtualBase_OnTransition(event *qt6.QEvent) { + + C.QEventTransition_virtualbase_onTransition(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QEventTransition) OnOnTransition(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QEventTransition_override_virtual_onTransition(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QEventTransition_onTransition +func miqt_exec_callback_QEventTransition_onTransition(self *C.QEventTransition, 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((&QEventTransition{h: self}).callVirtualBase_OnTransition, slotval1) + +} + +func (this *QEventTransition) callVirtualBase_Event(e *qt6.QEvent) bool { + + return (bool)(C.QEventTransition_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(e.UnsafePointer()))) + +} +func (this *QEventTransition) OnEvent(slot func(super func(e *qt6.QEvent) bool, e *qt6.QEvent) bool) { + ok := C.QEventTransition_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_QEventTransition_event +func miqt_exec_callback_QEventTransition_event(self *C.QEventTransition, cb C.intptr_t, e *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(e *qt6.QEvent) bool, e *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(e)) + + virtualReturn := gofunc((&QEventTransition{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QEventTransition) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QEventTransition_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QEventTransition) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QEventTransition_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_QEventTransition_eventFilter +func miqt_exec_callback_QEventTransition_eventFilter(self *C.QEventTransition, 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((&QEventTransition{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QEventTransition) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QEventTransition_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QEventTransition) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QEventTransition_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_QEventTransition_timerEvent +func miqt_exec_callback_QEventTransition_timerEvent(self *C.QEventTransition, 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((&QEventTransition{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QEventTransition) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QEventTransition_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QEventTransition) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QEventTransition_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_QEventTransition_childEvent +func miqt_exec_callback_QEventTransition_childEvent(self *C.QEventTransition, 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((&QEventTransition{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QEventTransition) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QEventTransition_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QEventTransition) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QEventTransition_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_QEventTransition_customEvent +func miqt_exec_callback_QEventTransition_customEvent(self *C.QEventTransition, 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((&QEventTransition{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QEventTransition) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QEventTransition_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QEventTransition) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QEventTransition_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_QEventTransition_connectNotify +func miqt_exec_callback_QEventTransition_connectNotify(self *C.QEventTransition, 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((&QEventTransition{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QEventTransition) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QEventTransition_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QEventTransition) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QEventTransition_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_QEventTransition_disconnectNotify +func miqt_exec_callback_QEventTransition_disconnectNotify(self *C.QEventTransition, 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((&QEventTransition{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QEventTransition) Delete() { + C.QEventTransition_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 *QEventTransition) GoGC() { + runtime.SetFinalizer(this, func(this *QEventTransition) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/statemachine/gen_qeventtransition.h b/qt6/statemachine/gen_qeventtransition.h new file mode 100644 index 000000000..74cb66c87 --- /dev/null +++ b/qt6/statemachine/gen_qeventtransition.h @@ -0,0 +1,87 @@ +#pragma once +#ifndef MIQT_QT6_STATEMACHINE_GEN_QEVENTTRANSITION_H +#define MIQT_QT6_STATEMACHINE_GEN_QEVENTTRANSITION_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractTransition; +class QChildEvent; +class QEvent; +class QEventTransition; +class QMetaMethod; +class QMetaObject; +class QObject; +class QState; +class QTimerEvent; +#else +typedef struct QAbstractTransition QAbstractTransition; +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QEventTransition QEventTransition; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QState QState; +typedef struct QTimerEvent QTimerEvent; +#endif + +QEventTransition* QEventTransition_new(); +QEventTransition* QEventTransition_new2(QObject* object, int type); +QEventTransition* QEventTransition_new3(QState* sourceState); +QEventTransition* QEventTransition_new4(QObject* object, int type, QState* sourceState); +void QEventTransition_virtbase(QEventTransition* src, QAbstractTransition** outptr_QAbstractTransition); +QMetaObject* QEventTransition_metaObject(const QEventTransition* self); +void* QEventTransition_metacast(QEventTransition* self, const char* param1); +struct miqt_string QEventTransition_tr(const char* s); +QObject* QEventTransition_eventSource(const QEventTransition* self); +void QEventTransition_setEventSource(QEventTransition* self, QObject* object); +int QEventTransition_eventType(const QEventTransition* self); +void QEventTransition_setEventType(QEventTransition* self, int type); +bool QEventTransition_eventTest(QEventTransition* self, QEvent* event); +void QEventTransition_onTransition(QEventTransition* self, QEvent* event); +bool QEventTransition_event(QEventTransition* self, QEvent* e); +struct miqt_string QEventTransition_tr2(const char* s, const char* c); +struct miqt_string QEventTransition_tr3(const char* s, const char* c, int n); + +bool QEventTransition_override_virtual_eventTest(void* self, intptr_t slot); +bool QEventTransition_virtualbase_eventTest(void* self, QEvent* event); +bool QEventTransition_override_virtual_onTransition(void* self, intptr_t slot); +void QEventTransition_virtualbase_onTransition(void* self, QEvent* event); +bool QEventTransition_override_virtual_event(void* self, intptr_t slot); +bool QEventTransition_virtualbase_event(void* self, QEvent* e); +bool QEventTransition_override_virtual_eventFilter(void* self, intptr_t slot); +bool QEventTransition_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QEventTransition_override_virtual_timerEvent(void* self, intptr_t slot); +void QEventTransition_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QEventTransition_override_virtual_childEvent(void* self, intptr_t slot); +void QEventTransition_virtualbase_childEvent(void* self, QChildEvent* event); +bool QEventTransition_override_virtual_customEvent(void* self, intptr_t slot); +void QEventTransition_virtualbase_customEvent(void* self, QEvent* event); +bool QEventTransition_override_virtual_connectNotify(void* self, intptr_t slot); +void QEventTransition_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QEventTransition_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QEventTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QEventTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QEventTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QEventTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QEventTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QEventTransition_delete(QEventTransition* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/statemachine/gen_qfinalstate.cpp b/qt6/statemachine/gen_qfinalstate.cpp new file mode 100644 index 000000000..41f8fb85d --- /dev/null +++ b/qt6/statemachine/gen_qfinalstate.cpp @@ -0,0 +1,430 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qfinalstate.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QFinalState_onEntry(QFinalState*, intptr_t, QEvent*); +void miqt_exec_callback_QFinalState_onExit(QFinalState*, intptr_t, QEvent*); +bool miqt_exec_callback_QFinalState_event(QFinalState*, intptr_t, QEvent*); +bool miqt_exec_callback_QFinalState_eventFilter(QFinalState*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QFinalState_timerEvent(QFinalState*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QFinalState_childEvent(QFinalState*, intptr_t, QChildEvent*); +void miqt_exec_callback_QFinalState_customEvent(QFinalState*, intptr_t, QEvent*); +void miqt_exec_callback_QFinalState_connectNotify(QFinalState*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QFinalState_disconnectNotify(QFinalState*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQFinalState final : public QFinalState { +public: + + MiqtVirtualQFinalState(): QFinalState() {} + MiqtVirtualQFinalState(QState* parent): QFinalState(parent) {} + + virtual ~MiqtVirtualQFinalState() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__onEntry = 0; + + // Subclass to allow providing a Go implementation + virtual void onEntry(QEvent* event) override { + if (handle__onEntry == 0) { + QFinalState::onEntry(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QFinalState_onEntry(this, handle__onEntry, sigval1); + + } + + friend void QFinalState_virtualbase_onEntry(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__onExit = 0; + + // Subclass to allow providing a Go implementation + virtual void onExit(QEvent* event) override { + if (handle__onExit == 0) { + QFinalState::onExit(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QFinalState_onExit(this, handle__onExit, sigval1); + + } + + friend void QFinalState_virtualbase_onExit(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* e) override { + if (handle__event == 0) { + return QFinalState::event(e); + } + + QEvent* sigval1 = e; + bool callback_return_value = miqt_exec_callback_QFinalState_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QFinalState_virtualbase_event(void* self, QEvent* e); + + // 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 QFinalState::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QFinalState_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QFinalState_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) { + QFinalState::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QFinalState_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QFinalState_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) { + QFinalState::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QFinalState_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QFinalState_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) { + QFinalState::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QFinalState_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QFinalState_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) { + QFinalState::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QFinalState_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QFinalState_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) { + QFinalState::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QFinalState_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QFinalState_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QFinalState_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QFinalState_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QFinalState_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QFinalState_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QFinalState* QFinalState_new() { + return new (std::nothrow) MiqtVirtualQFinalState(); +} + +QFinalState* QFinalState_new2(QState* parent) { + return new (std::nothrow) MiqtVirtualQFinalState(parent); +} + +void QFinalState_virtbase(QFinalState* src, QAbstractState** outptr_QAbstractState) { + *outptr_QAbstractState = static_cast(src); +} + +QMetaObject* QFinalState_metaObject(const QFinalState* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QFinalState_metacast(QFinalState* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QFinalState_tr(const char* s) { + QString _ret = QFinalState::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 QFinalState_tr2(const char* s, const char* c) { + QString _ret = QFinalState::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 QFinalState_tr3(const char* s, const char* c, int n) { + QString _ret = QFinalState::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 QFinalState_override_virtual_onEntry(void* self, intptr_t slot) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onEntry = slot; + return true; +} + +void QFinalState_virtualbase_onEntry(void* self, QEvent* event) { + static_cast(self)->QFinalState::onEntry(event); +} + +bool QFinalState_override_virtual_onExit(void* self, intptr_t slot) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onExit = slot; + return true; +} + +void QFinalState_virtualbase_onExit(void* self, QEvent* event) { + static_cast(self)->QFinalState::onExit(event); +} + +bool QFinalState_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QFinalState_virtualbase_event(void* self, QEvent* e) { + return static_cast(self)->QFinalState::event(e); +} + +bool QFinalState_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QFinalState_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QFinalState::eventFilter(watched, event); +} + +bool QFinalState_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QFinalState_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QFinalState::timerEvent(event); +} + +bool QFinalState_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QFinalState_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QFinalState::childEvent(event); +} + +bool QFinalState_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QFinalState_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QFinalState::customEvent(event); +} + +bool QFinalState_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QFinalState_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QFinalState::connectNotify(*signal); +} + +bool QFinalState_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QFinalState_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QFinalState::disconnectNotify(*signal); +} + +QObject* QFinalState_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QFinalState_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QFinalState_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QFinalState_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQFinalState* self_cast = dynamic_cast( (QFinalState*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QFinalState_delete(QFinalState* self) { + delete self; +} + diff --git a/qt6/statemachine/gen_qfinalstate.go b/qt6/statemachine/gen_qfinalstate.go new file mode 100644 index 000000000..e754baa57 --- /dev/null +++ b/qt6/statemachine/gen_qfinalstate.go @@ -0,0 +1,417 @@ +package statemachine + +/* + +#include "gen_qfinalstate.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QFinalState struct { + h *C.QFinalState + *QAbstractState +} + +func (this *QFinalState) cPointer() *C.QFinalState { + if this == nil { + return nil + } + return this.h +} + +func (this *QFinalState) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQFinalState constructs the type using only CGO pointers. +func newQFinalState(h *C.QFinalState) *QFinalState { + if h == nil { + return nil + } + var outptr_QAbstractState *C.QAbstractState = nil + C.QFinalState_virtbase(h, &outptr_QAbstractState) + + return &QFinalState{h: h, + QAbstractState: newQAbstractState(outptr_QAbstractState)} +} + +// UnsafeNewQFinalState constructs the type using only unsafe pointers. +func UnsafeNewQFinalState(h unsafe.Pointer) *QFinalState { + return newQFinalState((*C.QFinalState)(h)) +} + +// NewQFinalState constructs a new QFinalState object. +func NewQFinalState() *QFinalState { + + return newQFinalState(C.QFinalState_new()) +} + +// NewQFinalState2 constructs a new QFinalState object. +func NewQFinalState2(parent *QState) *QFinalState { + + return newQFinalState(C.QFinalState_new2(parent.cPointer())) +} + +func (this *QFinalState) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QFinalState_metaObject(this.h))) +} + +func (this *QFinalState) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QFinalState_metacast(this.h, param1_Cstring)) +} + +func QFinalState_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QFinalState_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QFinalState_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.QFinalState_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QFinalState_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.QFinalState_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 +} + +// Sender can only be called from a QFinalState that was directly constructed. +func (this *QFinalState) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QFinalState_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 QFinalState that was directly constructed. +func (this *QFinalState) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QFinalState_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 QFinalState that was directly constructed. +func (this *QFinalState) 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.QFinalState_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 QFinalState that was directly constructed. +func (this *QFinalState) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QFinalState_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 *QFinalState) callVirtualBase_OnEntry(event *qt6.QEvent) { + + C.QFinalState_virtualbase_onEntry(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QFinalState) OnOnEntry(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QFinalState_override_virtual_onEntry(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QFinalState_onEntry +func miqt_exec_callback_QFinalState_onEntry(self *C.QFinalState, 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((&QFinalState{h: self}).callVirtualBase_OnEntry, slotval1) + +} + +func (this *QFinalState) callVirtualBase_OnExit(event *qt6.QEvent) { + + C.QFinalState_virtualbase_onExit(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QFinalState) OnOnExit(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QFinalState_override_virtual_onExit(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QFinalState_onExit +func miqt_exec_callback_QFinalState_onExit(self *C.QFinalState, 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((&QFinalState{h: self}).callVirtualBase_OnExit, slotval1) + +} + +func (this *QFinalState) callVirtualBase_Event(e *qt6.QEvent) bool { + + return (bool)(C.QFinalState_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(e.UnsafePointer()))) + +} +func (this *QFinalState) OnEvent(slot func(super func(e *qt6.QEvent) bool, e *qt6.QEvent) bool) { + ok := C.QFinalState_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_QFinalState_event +func miqt_exec_callback_QFinalState_event(self *C.QFinalState, cb C.intptr_t, e *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(e *qt6.QEvent) bool, e *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(e)) + + virtualReturn := gofunc((&QFinalState{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QFinalState) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QFinalState_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QFinalState) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QFinalState_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_QFinalState_eventFilter +func miqt_exec_callback_QFinalState_eventFilter(self *C.QFinalState, 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((&QFinalState{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QFinalState) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QFinalState_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QFinalState) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QFinalState_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_QFinalState_timerEvent +func miqt_exec_callback_QFinalState_timerEvent(self *C.QFinalState, 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((&QFinalState{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QFinalState) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QFinalState_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QFinalState) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QFinalState_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_QFinalState_childEvent +func miqt_exec_callback_QFinalState_childEvent(self *C.QFinalState, 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((&QFinalState{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QFinalState) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QFinalState_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QFinalState) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QFinalState_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_QFinalState_customEvent +func miqt_exec_callback_QFinalState_customEvent(self *C.QFinalState, 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((&QFinalState{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QFinalState) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QFinalState_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QFinalState) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QFinalState_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_QFinalState_connectNotify +func miqt_exec_callback_QFinalState_connectNotify(self *C.QFinalState, 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((&QFinalState{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QFinalState) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QFinalState_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QFinalState) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QFinalState_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_QFinalState_disconnectNotify +func miqt_exec_callback_QFinalState_disconnectNotify(self *C.QFinalState, 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((&QFinalState{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QFinalState) Delete() { + C.QFinalState_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 *QFinalState) GoGC() { + runtime.SetFinalizer(this, func(this *QFinalState) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/statemachine/gen_qfinalstate.h b/qt6/statemachine/gen_qfinalstate.h new file mode 100644 index 000000000..ed76317e0 --- /dev/null +++ b/qt6/statemachine/gen_qfinalstate.h @@ -0,0 +1,81 @@ +#pragma once +#ifndef MIQT_QT6_STATEMACHINE_GEN_QFINALSTATE_H +#define MIQT_QT6_STATEMACHINE_GEN_QFINALSTATE_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractState; +class QChildEvent; +class QEvent; +class QFinalState; +class QMetaMethod; +class QMetaObject; +class QObject; +class QState; +class QTimerEvent; +#else +typedef struct QAbstractState QAbstractState; +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QFinalState QFinalState; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QState QState; +typedef struct QTimerEvent QTimerEvent; +#endif + +QFinalState* QFinalState_new(); +QFinalState* QFinalState_new2(QState* parent); +void QFinalState_virtbase(QFinalState* src, QAbstractState** outptr_QAbstractState); +QMetaObject* QFinalState_metaObject(const QFinalState* self); +void* QFinalState_metacast(QFinalState* self, const char* param1); +struct miqt_string QFinalState_tr(const char* s); +void QFinalState_onEntry(QFinalState* self, QEvent* event); +void QFinalState_onExit(QFinalState* self, QEvent* event); +bool QFinalState_event(QFinalState* self, QEvent* e); +struct miqt_string QFinalState_tr2(const char* s, const char* c); +struct miqt_string QFinalState_tr3(const char* s, const char* c, int n); + +bool QFinalState_override_virtual_onEntry(void* self, intptr_t slot); +void QFinalState_virtualbase_onEntry(void* self, QEvent* event); +bool QFinalState_override_virtual_onExit(void* self, intptr_t slot); +void QFinalState_virtualbase_onExit(void* self, QEvent* event); +bool QFinalState_override_virtual_event(void* self, intptr_t slot); +bool QFinalState_virtualbase_event(void* self, QEvent* e); +bool QFinalState_override_virtual_eventFilter(void* self, intptr_t slot); +bool QFinalState_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QFinalState_override_virtual_timerEvent(void* self, intptr_t slot); +void QFinalState_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QFinalState_override_virtual_childEvent(void* self, intptr_t slot); +void QFinalState_virtualbase_childEvent(void* self, QChildEvent* event); +bool QFinalState_override_virtual_customEvent(void* self, intptr_t slot); +void QFinalState_virtualbase_customEvent(void* self, QEvent* event); +bool QFinalState_override_virtual_connectNotify(void* self, intptr_t slot); +void QFinalState_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QFinalState_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QFinalState_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QFinalState_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QFinalState_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QFinalState_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QFinalState_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QFinalState_delete(QFinalState* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/statemachine/gen_qhistorystate.cpp b/qt6/statemachine/gen_qhistorystate.cpp new file mode 100644 index 000000000..c5521313c --- /dev/null +++ b/qt6/statemachine/gen_qhistorystate.cpp @@ -0,0 +1,487 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qhistorystate.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QHistoryState_defaultTransitionChanged(intptr_t); +void miqt_exec_callback_QHistoryState_defaultStateChanged(intptr_t); +void miqt_exec_callback_QHistoryState_historyTypeChanged(intptr_t); +void miqt_exec_callback_QHistoryState_onEntry(QHistoryState*, intptr_t, QEvent*); +void miqt_exec_callback_QHistoryState_onExit(QHistoryState*, intptr_t, QEvent*); +bool miqt_exec_callback_QHistoryState_event(QHistoryState*, intptr_t, QEvent*); +bool miqt_exec_callback_QHistoryState_eventFilter(QHistoryState*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QHistoryState_timerEvent(QHistoryState*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QHistoryState_childEvent(QHistoryState*, intptr_t, QChildEvent*); +void miqt_exec_callback_QHistoryState_customEvent(QHistoryState*, intptr_t, QEvent*); +void miqt_exec_callback_QHistoryState_connectNotify(QHistoryState*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QHistoryState_disconnectNotify(QHistoryState*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQHistoryState final : public QHistoryState { +public: + + MiqtVirtualQHistoryState(): QHistoryState() {} + MiqtVirtualQHistoryState(QHistoryState::HistoryType type): QHistoryState(type) {} + MiqtVirtualQHistoryState(QState* parent): QHistoryState(parent) {} + MiqtVirtualQHistoryState(QHistoryState::HistoryType type, QState* parent): QHistoryState(type, parent) {} + + virtual ~MiqtVirtualQHistoryState() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__onEntry = 0; + + // Subclass to allow providing a Go implementation + virtual void onEntry(QEvent* event) override { + if (handle__onEntry == 0) { + QHistoryState::onEntry(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QHistoryState_onEntry(this, handle__onEntry, sigval1); + + } + + friend void QHistoryState_virtualbase_onEntry(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__onExit = 0; + + // Subclass to allow providing a Go implementation + virtual void onExit(QEvent* event) override { + if (handle__onExit == 0) { + QHistoryState::onExit(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QHistoryState_onExit(this, handle__onExit, sigval1); + + } + + friend void QHistoryState_virtualbase_onExit(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* e) override { + if (handle__event == 0) { + return QHistoryState::event(e); + } + + QEvent* sigval1 = e; + bool callback_return_value = miqt_exec_callback_QHistoryState_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QHistoryState_virtualbase_event(void* self, QEvent* e); + + // 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 QHistoryState::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QHistoryState_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QHistoryState_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) { + QHistoryState::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QHistoryState_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QHistoryState_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) { + QHistoryState::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QHistoryState_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QHistoryState_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) { + QHistoryState::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QHistoryState_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QHistoryState_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) { + QHistoryState::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QHistoryState_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QHistoryState_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) { + QHistoryState::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QHistoryState_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QHistoryState_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QHistoryState_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QHistoryState_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QHistoryState_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QHistoryState_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QHistoryState* QHistoryState_new() { + return new (std::nothrow) MiqtVirtualQHistoryState(); +} + +QHistoryState* QHistoryState_new2(int type) { + return new (std::nothrow) MiqtVirtualQHistoryState(static_cast(type)); +} + +QHistoryState* QHistoryState_new3(QState* parent) { + return new (std::nothrow) MiqtVirtualQHistoryState(parent); +} + +QHistoryState* QHistoryState_new4(int type, QState* parent) { + return new (std::nothrow) MiqtVirtualQHistoryState(static_cast(type), parent); +} + +void QHistoryState_virtbase(QHistoryState* src, QAbstractState** outptr_QAbstractState) { + *outptr_QAbstractState = static_cast(src); +} + +QMetaObject* QHistoryState_metaObject(const QHistoryState* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QHistoryState_metacast(QHistoryState* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QHistoryState_tr(const char* s) { + QString _ret = QHistoryState::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; +} + +QAbstractTransition* QHistoryState_defaultTransition(const QHistoryState* self) { + return self->defaultTransition(); +} + +void QHistoryState_setDefaultTransition(QHistoryState* self, QAbstractTransition* transition) { + self->setDefaultTransition(transition); +} + +QAbstractState* QHistoryState_defaultState(const QHistoryState* self) { + return self->defaultState(); +} + +void QHistoryState_setDefaultState(QHistoryState* self, QAbstractState* state) { + self->setDefaultState(state); +} + +int QHistoryState_historyType(const QHistoryState* self) { + QHistoryState::HistoryType _ret = self->historyType(); + return static_cast(_ret); +} + +void QHistoryState_setHistoryType(QHistoryState* self, int type) { + self->setHistoryType(static_cast(type)); +} + +struct miqt_string QHistoryState_tr2(const char* s, const char* c) { + QString _ret = QHistoryState::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 QHistoryState_tr3(const char* s, const char* c, int n) { + QString _ret = QHistoryState::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 QHistoryState_override_virtual_onEntry(void* self, intptr_t slot) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onEntry = slot; + return true; +} + +void QHistoryState_virtualbase_onEntry(void* self, QEvent* event) { + static_cast(self)->QHistoryState::onEntry(event); +} + +bool QHistoryState_override_virtual_onExit(void* self, intptr_t slot) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onExit = slot; + return true; +} + +void QHistoryState_virtualbase_onExit(void* self, QEvent* event) { + static_cast(self)->QHistoryState::onExit(event); +} + +bool QHistoryState_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QHistoryState_virtualbase_event(void* self, QEvent* e) { + return static_cast(self)->QHistoryState::event(e); +} + +bool QHistoryState_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QHistoryState_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QHistoryState::eventFilter(watched, event); +} + +bool QHistoryState_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QHistoryState_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QHistoryState::timerEvent(event); +} + +bool QHistoryState_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QHistoryState_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QHistoryState::childEvent(event); +} + +bool QHistoryState_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QHistoryState_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QHistoryState::customEvent(event); +} + +bool QHistoryState_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QHistoryState_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QHistoryState::connectNotify(*signal); +} + +bool QHistoryState_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QHistoryState_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QHistoryState::disconnectNotify(*signal); +} + +QObject* QHistoryState_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QHistoryState_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QHistoryState_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QHistoryState_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQHistoryState* self_cast = dynamic_cast( (QHistoryState*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QHistoryState_connect_defaultTransitionChanged(QHistoryState* self, intptr_t slot) { + QHistoryState::connect(self, &QHistoryState::defaultTransitionChanged, self, [=]() { + miqt_exec_callback_QHistoryState_defaultTransitionChanged(slot); + }); +} + +void QHistoryState_connect_defaultStateChanged(QHistoryState* self, intptr_t slot) { + QHistoryState::connect(self, &QHistoryState::defaultStateChanged, self, [=]() { + miqt_exec_callback_QHistoryState_defaultStateChanged(slot); + }); +} + +void QHistoryState_connect_historyTypeChanged(QHistoryState* self, intptr_t slot) { + QHistoryState::connect(self, &QHistoryState::historyTypeChanged, self, [=]() { + miqt_exec_callback_QHistoryState_historyTypeChanged(slot); + }); +} + +void QHistoryState_delete(QHistoryState* self) { + delete self; +} + diff --git a/qt6/statemachine/gen_qhistorystate.go b/qt6/statemachine/gen_qhistorystate.go new file mode 100644 index 000000000..1028d634e --- /dev/null +++ b/qt6/statemachine/gen_qhistorystate.go @@ -0,0 +1,501 @@ +package statemachine + +/* + +#include "gen_qhistorystate.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QHistoryState__HistoryType int + +const ( + QHistoryState__ShallowHistory QHistoryState__HistoryType = 0 + QHistoryState__DeepHistory QHistoryState__HistoryType = 1 +) + +type QHistoryState struct { + h *C.QHistoryState + *QAbstractState +} + +func (this *QHistoryState) cPointer() *C.QHistoryState { + if this == nil { + return nil + } + return this.h +} + +func (this *QHistoryState) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQHistoryState constructs the type using only CGO pointers. +func newQHistoryState(h *C.QHistoryState) *QHistoryState { + if h == nil { + return nil + } + var outptr_QAbstractState *C.QAbstractState = nil + C.QHistoryState_virtbase(h, &outptr_QAbstractState) + + return &QHistoryState{h: h, + QAbstractState: newQAbstractState(outptr_QAbstractState)} +} + +// UnsafeNewQHistoryState constructs the type using only unsafe pointers. +func UnsafeNewQHistoryState(h unsafe.Pointer) *QHistoryState { + return newQHistoryState((*C.QHistoryState)(h)) +} + +// NewQHistoryState constructs a new QHistoryState object. +func NewQHistoryState() *QHistoryState { + + return newQHistoryState(C.QHistoryState_new()) +} + +// NewQHistoryState2 constructs a new QHistoryState object. +func NewQHistoryState2(typeVal QHistoryState__HistoryType) *QHistoryState { + + return newQHistoryState(C.QHistoryState_new2((C.int)(typeVal))) +} + +// NewQHistoryState3 constructs a new QHistoryState object. +func NewQHistoryState3(parent *QState) *QHistoryState { + + return newQHistoryState(C.QHistoryState_new3(parent.cPointer())) +} + +// NewQHistoryState4 constructs a new QHistoryState object. +func NewQHistoryState4(typeVal QHistoryState__HistoryType, parent *QState) *QHistoryState { + + return newQHistoryState(C.QHistoryState_new4((C.int)(typeVal), parent.cPointer())) +} + +func (this *QHistoryState) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QHistoryState_metaObject(this.h))) +} + +func (this *QHistoryState) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QHistoryState_metacast(this.h, param1_Cstring)) +} + +func QHistoryState_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QHistoryState_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QHistoryState) DefaultTransition() *QAbstractTransition { + return newQAbstractTransition(C.QHistoryState_defaultTransition(this.h)) +} + +func (this *QHistoryState) SetDefaultTransition(transition *QAbstractTransition) { + C.QHistoryState_setDefaultTransition(this.h, transition.cPointer()) +} + +func (this *QHistoryState) DefaultState() *QAbstractState { + return newQAbstractState(C.QHistoryState_defaultState(this.h)) +} + +func (this *QHistoryState) SetDefaultState(state *QAbstractState) { + C.QHistoryState_setDefaultState(this.h, state.cPointer()) +} + +func (this *QHistoryState) HistoryType() QHistoryState__HistoryType { + return (QHistoryState__HistoryType)(C.QHistoryState_historyType(this.h)) +} + +func (this *QHistoryState) SetHistoryType(typeVal QHistoryState__HistoryType) { + C.QHistoryState_setHistoryType(this.h, (C.int)(typeVal)) +} + +func QHistoryState_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.QHistoryState_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QHistoryState_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.QHistoryState_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 +} + +// Sender can only be called from a QHistoryState that was directly constructed. +func (this *QHistoryState) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QHistoryState_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 QHistoryState that was directly constructed. +func (this *QHistoryState) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QHistoryState_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 QHistoryState that was directly constructed. +func (this *QHistoryState) 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.QHistoryState_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 QHistoryState that was directly constructed. +func (this *QHistoryState) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QHistoryState_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 *QHistoryState) callVirtualBase_OnEntry(event *qt6.QEvent) { + + C.QHistoryState_virtualbase_onEntry(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QHistoryState) OnOnEntry(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QHistoryState_override_virtual_onEntry(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QHistoryState_onEntry +func miqt_exec_callback_QHistoryState_onEntry(self *C.QHistoryState, 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((&QHistoryState{h: self}).callVirtualBase_OnEntry, slotval1) + +} + +func (this *QHistoryState) callVirtualBase_OnExit(event *qt6.QEvent) { + + C.QHistoryState_virtualbase_onExit(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QHistoryState) OnOnExit(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QHistoryState_override_virtual_onExit(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QHistoryState_onExit +func miqt_exec_callback_QHistoryState_onExit(self *C.QHistoryState, 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((&QHistoryState{h: self}).callVirtualBase_OnExit, slotval1) + +} + +func (this *QHistoryState) callVirtualBase_Event(e *qt6.QEvent) bool { + + return (bool)(C.QHistoryState_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(e.UnsafePointer()))) + +} +func (this *QHistoryState) OnEvent(slot func(super func(e *qt6.QEvent) bool, e *qt6.QEvent) bool) { + ok := C.QHistoryState_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_QHistoryState_event +func miqt_exec_callback_QHistoryState_event(self *C.QHistoryState, cb C.intptr_t, e *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(e *qt6.QEvent) bool, e *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(e)) + + virtualReturn := gofunc((&QHistoryState{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QHistoryState) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QHistoryState_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QHistoryState) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QHistoryState_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_QHistoryState_eventFilter +func miqt_exec_callback_QHistoryState_eventFilter(self *C.QHistoryState, 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((&QHistoryState{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QHistoryState) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QHistoryState_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QHistoryState) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QHistoryState_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_QHistoryState_timerEvent +func miqt_exec_callback_QHistoryState_timerEvent(self *C.QHistoryState, 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((&QHistoryState{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QHistoryState) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QHistoryState_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QHistoryState) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QHistoryState_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_QHistoryState_childEvent +func miqt_exec_callback_QHistoryState_childEvent(self *C.QHistoryState, 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((&QHistoryState{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QHistoryState) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QHistoryState_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QHistoryState) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QHistoryState_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_QHistoryState_customEvent +func miqt_exec_callback_QHistoryState_customEvent(self *C.QHistoryState, 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((&QHistoryState{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QHistoryState) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QHistoryState_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QHistoryState) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QHistoryState_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_QHistoryState_connectNotify +func miqt_exec_callback_QHistoryState_connectNotify(self *C.QHistoryState, 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((&QHistoryState{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QHistoryState) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QHistoryState_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QHistoryState) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QHistoryState_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_QHistoryState_disconnectNotify +func miqt_exec_callback_QHistoryState_disconnectNotify(self *C.QHistoryState, 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((&QHistoryState{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} +func (this *QHistoryState) OnDefaultTransitionChanged(slot func()) { + C.QHistoryState_connect_defaultTransitionChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QHistoryState_defaultTransitionChanged +func miqt_exec_callback_QHistoryState_defaultTransitionChanged(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 *QHistoryState) OnDefaultStateChanged(slot func()) { + C.QHistoryState_connect_defaultStateChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QHistoryState_defaultStateChanged +func miqt_exec_callback_QHistoryState_defaultStateChanged(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 *QHistoryState) OnHistoryTypeChanged(slot func()) { + C.QHistoryState_connect_historyTypeChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QHistoryState_historyTypeChanged +func miqt_exec_callback_QHistoryState_historyTypeChanged(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +// Delete this object from C++ memory. +func (this *QHistoryState) Delete() { + C.QHistoryState_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 *QHistoryState) GoGC() { + runtime.SetFinalizer(this, func(this *QHistoryState) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/statemachine/gen_qhistorystate.h b/qt6/statemachine/gen_qhistorystate.h new file mode 100644 index 000000000..30e300fe4 --- /dev/null +++ b/qt6/statemachine/gen_qhistorystate.h @@ -0,0 +1,95 @@ +#pragma once +#ifndef MIQT_QT6_STATEMACHINE_GEN_QHISTORYSTATE_H +#define MIQT_QT6_STATEMACHINE_GEN_QHISTORYSTATE_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractState; +class QAbstractTransition; +class QChildEvent; +class QEvent; +class QHistoryState; +class QMetaMethod; +class QMetaObject; +class QObject; +class QState; +class QTimerEvent; +#else +typedef struct QAbstractState QAbstractState; +typedef struct QAbstractTransition QAbstractTransition; +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QHistoryState QHistoryState; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QState QState; +typedef struct QTimerEvent QTimerEvent; +#endif + +QHistoryState* QHistoryState_new(); +QHistoryState* QHistoryState_new2(int type); +QHistoryState* QHistoryState_new3(QState* parent); +QHistoryState* QHistoryState_new4(int type, QState* parent); +void QHistoryState_virtbase(QHistoryState* src, QAbstractState** outptr_QAbstractState); +QMetaObject* QHistoryState_metaObject(const QHistoryState* self); +void* QHistoryState_metacast(QHistoryState* self, const char* param1); +struct miqt_string QHistoryState_tr(const char* s); +QAbstractTransition* QHistoryState_defaultTransition(const QHistoryState* self); +void QHistoryState_setDefaultTransition(QHistoryState* self, QAbstractTransition* transition); +QAbstractState* QHistoryState_defaultState(const QHistoryState* self); +void QHistoryState_setDefaultState(QHistoryState* self, QAbstractState* state); +int QHistoryState_historyType(const QHistoryState* self); +void QHistoryState_setHistoryType(QHistoryState* self, int type); +void QHistoryState_onEntry(QHistoryState* self, QEvent* event); +void QHistoryState_onExit(QHistoryState* self, QEvent* event); +bool QHistoryState_event(QHistoryState* self, QEvent* e); +struct miqt_string QHistoryState_tr2(const char* s, const char* c); +struct miqt_string QHistoryState_tr3(const char* s, const char* c, int n); + +bool QHistoryState_override_virtual_onEntry(void* self, intptr_t slot); +void QHistoryState_virtualbase_onEntry(void* self, QEvent* event); +bool QHistoryState_override_virtual_onExit(void* self, intptr_t slot); +void QHistoryState_virtualbase_onExit(void* self, QEvent* event); +bool QHistoryState_override_virtual_event(void* self, intptr_t slot); +bool QHistoryState_virtualbase_event(void* self, QEvent* e); +bool QHistoryState_override_virtual_eventFilter(void* self, intptr_t slot); +bool QHistoryState_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QHistoryState_override_virtual_timerEvent(void* self, intptr_t slot); +void QHistoryState_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QHistoryState_override_virtual_childEvent(void* self, intptr_t slot); +void QHistoryState_virtualbase_childEvent(void* self, QChildEvent* event); +bool QHistoryState_override_virtual_customEvent(void* self, intptr_t slot); +void QHistoryState_virtualbase_customEvent(void* self, QEvent* event); +bool QHistoryState_override_virtual_connectNotify(void* self, intptr_t slot); +void QHistoryState_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QHistoryState_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QHistoryState_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QHistoryState_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QHistoryState_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QHistoryState_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QHistoryState_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QHistoryState_connect_defaultTransitionChanged(QHistoryState* self, intptr_t slot); +void QHistoryState_connect_defaultStateChanged(QHistoryState* self, intptr_t slot); +void QHistoryState_connect_historyTypeChanged(QHistoryState* self, intptr_t slot); + +void QHistoryState_delete(QHistoryState* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/statemachine/gen_qkeyeventtransition.cpp b/qt6/statemachine/gen_qkeyeventtransition.cpp new file mode 100644 index 000000000..296328582 --- /dev/null +++ b/qt6/statemachine/gen_qkeyeventtransition.cpp @@ -0,0 +1,457 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qkeyeventtransition.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QKeyEventTransition_onTransition(QKeyEventTransition*, intptr_t, QEvent*); +bool miqt_exec_callback_QKeyEventTransition_eventTest(QKeyEventTransition*, intptr_t, QEvent*); +bool miqt_exec_callback_QKeyEventTransition_event(QKeyEventTransition*, intptr_t, QEvent*); +bool miqt_exec_callback_QKeyEventTransition_eventFilter(QKeyEventTransition*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QKeyEventTransition_timerEvent(QKeyEventTransition*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QKeyEventTransition_childEvent(QKeyEventTransition*, intptr_t, QChildEvent*); +void miqt_exec_callback_QKeyEventTransition_customEvent(QKeyEventTransition*, intptr_t, QEvent*); +void miqt_exec_callback_QKeyEventTransition_connectNotify(QKeyEventTransition*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QKeyEventTransition_disconnectNotify(QKeyEventTransition*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQKeyEventTransition final : public QKeyEventTransition { +public: + + MiqtVirtualQKeyEventTransition(): QKeyEventTransition() {} + MiqtVirtualQKeyEventTransition(QObject* object, QEvent::Type type, int key): QKeyEventTransition(object, type, key) {} + MiqtVirtualQKeyEventTransition(QState* sourceState): QKeyEventTransition(sourceState) {} + MiqtVirtualQKeyEventTransition(QObject* object, QEvent::Type type, int key, QState* sourceState): QKeyEventTransition(object, type, key, sourceState) {} + + virtual ~MiqtVirtualQKeyEventTransition() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__onTransition = 0; + + // Subclass to allow providing a Go implementation + virtual void onTransition(QEvent* event) override { + if (handle__onTransition == 0) { + QKeyEventTransition::onTransition(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QKeyEventTransition_onTransition(this, handle__onTransition, sigval1); + + } + + friend void QKeyEventTransition_virtualbase_onTransition(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventTest = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventTest(QEvent* event) override { + if (handle__eventTest == 0) { + return QKeyEventTransition::eventTest(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QKeyEventTransition_eventTest(this, handle__eventTest, sigval1); + return callback_return_value; + } + + friend bool QKeyEventTransition_virtualbase_eventTest(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* e) override { + if (handle__event == 0) { + return QKeyEventTransition::event(e); + } + + QEvent* sigval1 = e; + bool callback_return_value = miqt_exec_callback_QKeyEventTransition_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QKeyEventTransition_virtualbase_event(void* self, QEvent* e); + + // 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 QKeyEventTransition::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QKeyEventTransition_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QKeyEventTransition_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) { + QKeyEventTransition::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QKeyEventTransition_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QKeyEventTransition_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) { + QKeyEventTransition::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QKeyEventTransition_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QKeyEventTransition_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) { + QKeyEventTransition::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QKeyEventTransition_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QKeyEventTransition_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) { + QKeyEventTransition::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QKeyEventTransition_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QKeyEventTransition_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) { + QKeyEventTransition::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QKeyEventTransition_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QKeyEventTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QKeyEventTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QKeyEventTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QKeyEventTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QKeyEventTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QKeyEventTransition* QKeyEventTransition_new() { + return new (std::nothrow) MiqtVirtualQKeyEventTransition(); +} + +QKeyEventTransition* QKeyEventTransition_new2(QObject* object, int type, int key) { + return new (std::nothrow) MiqtVirtualQKeyEventTransition(object, static_cast(type), static_cast(key)); +} + +QKeyEventTransition* QKeyEventTransition_new3(QState* sourceState) { + return new (std::nothrow) MiqtVirtualQKeyEventTransition(sourceState); +} + +QKeyEventTransition* QKeyEventTransition_new4(QObject* object, int type, int key, QState* sourceState) { + return new (std::nothrow) MiqtVirtualQKeyEventTransition(object, static_cast(type), static_cast(key), sourceState); +} + +void QKeyEventTransition_virtbase(QKeyEventTransition* src, QEventTransition** outptr_QEventTransition) { + *outptr_QEventTransition = static_cast(src); +} + +QMetaObject* QKeyEventTransition_metaObject(const QKeyEventTransition* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QKeyEventTransition_metacast(QKeyEventTransition* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QKeyEventTransition_tr(const char* s) { + QString _ret = QKeyEventTransition::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 QKeyEventTransition_key(const QKeyEventTransition* self) { + return self->key(); +} + +void QKeyEventTransition_setKey(QKeyEventTransition* self, int key) { + self->setKey(static_cast(key)); +} + +int QKeyEventTransition_modifierMask(const QKeyEventTransition* self) { + Qt::KeyboardModifiers _ret = self->modifierMask(); + return static_cast(_ret); +} + +void QKeyEventTransition_setModifierMask(QKeyEventTransition* self, int modifiers) { + self->setModifierMask(static_cast(modifiers)); +} + +struct miqt_string QKeyEventTransition_tr2(const char* s, const char* c) { + QString _ret = QKeyEventTransition::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 QKeyEventTransition_tr3(const char* s, const char* c, int n) { + QString _ret = QKeyEventTransition::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 QKeyEventTransition_override_virtual_onTransition(void* self, intptr_t slot) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onTransition = slot; + return true; +} + +void QKeyEventTransition_virtualbase_onTransition(void* self, QEvent* event) { + static_cast(self)->QKeyEventTransition::onTransition(event); +} + +bool QKeyEventTransition_override_virtual_eventTest(void* self, intptr_t slot) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventTest = slot; + return true; +} + +bool QKeyEventTransition_virtualbase_eventTest(void* self, QEvent* event) { + return static_cast(self)->QKeyEventTransition::eventTest(event); +} + +bool QKeyEventTransition_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QKeyEventTransition_virtualbase_event(void* self, QEvent* e) { + return static_cast(self)->QKeyEventTransition::event(e); +} + +bool QKeyEventTransition_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QKeyEventTransition_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QKeyEventTransition::eventFilter(watched, event); +} + +bool QKeyEventTransition_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QKeyEventTransition_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QKeyEventTransition::timerEvent(event); +} + +bool QKeyEventTransition_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QKeyEventTransition_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QKeyEventTransition::childEvent(event); +} + +bool QKeyEventTransition_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QKeyEventTransition_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QKeyEventTransition::customEvent(event); +} + +bool QKeyEventTransition_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QKeyEventTransition_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QKeyEventTransition::connectNotify(*signal); +} + +bool QKeyEventTransition_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QKeyEventTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QKeyEventTransition::disconnectNotify(*signal); +} + +QObject* QKeyEventTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QKeyEventTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QKeyEventTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QKeyEventTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQKeyEventTransition* self_cast = dynamic_cast( (QKeyEventTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QKeyEventTransition_delete(QKeyEventTransition* self) { + delete self; +} + diff --git a/qt6/statemachine/gen_qkeyeventtransition.go b/qt6/statemachine/gen_qkeyeventtransition.go new file mode 100644 index 000000000..20a821828 --- /dev/null +++ b/qt6/statemachine/gen_qkeyeventtransition.go @@ -0,0 +1,447 @@ +package statemachine + +/* + +#include "gen_qkeyeventtransition.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QKeyEventTransition struct { + h *C.QKeyEventTransition + *QEventTransition +} + +func (this *QKeyEventTransition) cPointer() *C.QKeyEventTransition { + if this == nil { + return nil + } + return this.h +} + +func (this *QKeyEventTransition) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQKeyEventTransition constructs the type using only CGO pointers. +func newQKeyEventTransition(h *C.QKeyEventTransition) *QKeyEventTransition { + if h == nil { + return nil + } + var outptr_QEventTransition *C.QEventTransition = nil + C.QKeyEventTransition_virtbase(h, &outptr_QEventTransition) + + return &QKeyEventTransition{h: h, + QEventTransition: newQEventTransition(outptr_QEventTransition)} +} + +// UnsafeNewQKeyEventTransition constructs the type using only unsafe pointers. +func UnsafeNewQKeyEventTransition(h unsafe.Pointer) *QKeyEventTransition { + return newQKeyEventTransition((*C.QKeyEventTransition)(h)) +} + +// NewQKeyEventTransition constructs a new QKeyEventTransition object. +func NewQKeyEventTransition() *QKeyEventTransition { + + return newQKeyEventTransition(C.QKeyEventTransition_new()) +} + +// NewQKeyEventTransition2 constructs a new QKeyEventTransition object. +func NewQKeyEventTransition2(object *qt6.QObject, typeVal qt6.QEvent__Type, key int) *QKeyEventTransition { + + return newQKeyEventTransition(C.QKeyEventTransition_new2((*C.QObject)(object.UnsafePointer()), (C.int)(typeVal), (C.int)(key))) +} + +// NewQKeyEventTransition3 constructs a new QKeyEventTransition object. +func NewQKeyEventTransition3(sourceState *QState) *QKeyEventTransition { + + return newQKeyEventTransition(C.QKeyEventTransition_new3(sourceState.cPointer())) +} + +// NewQKeyEventTransition4 constructs a new QKeyEventTransition object. +func NewQKeyEventTransition4(object *qt6.QObject, typeVal qt6.QEvent__Type, key int, sourceState *QState) *QKeyEventTransition { + + return newQKeyEventTransition(C.QKeyEventTransition_new4((*C.QObject)(object.UnsafePointer()), (C.int)(typeVal), (C.int)(key), sourceState.cPointer())) +} + +func (this *QKeyEventTransition) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QKeyEventTransition_metaObject(this.h))) +} + +func (this *QKeyEventTransition) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QKeyEventTransition_metacast(this.h, param1_Cstring)) +} + +func QKeyEventTransition_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QKeyEventTransition_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QKeyEventTransition) Key() int { + return (int)(C.QKeyEventTransition_key(this.h)) +} + +func (this *QKeyEventTransition) SetKey(key int) { + C.QKeyEventTransition_setKey(this.h, (C.int)(key)) +} + +func (this *QKeyEventTransition) ModifierMask() qt6.KeyboardModifier { + return (qt6.KeyboardModifier)(C.QKeyEventTransition_modifierMask(this.h)) +} + +func (this *QKeyEventTransition) SetModifierMask(modifiers qt6.KeyboardModifier) { + C.QKeyEventTransition_setModifierMask(this.h, (C.int)(modifiers)) +} + +func QKeyEventTransition_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.QKeyEventTransition_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QKeyEventTransition_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.QKeyEventTransition_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 +} + +// Sender can only be called from a QKeyEventTransition that was directly constructed. +func (this *QKeyEventTransition) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QKeyEventTransition_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 QKeyEventTransition that was directly constructed. +func (this *QKeyEventTransition) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QKeyEventTransition_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 QKeyEventTransition that was directly constructed. +func (this *QKeyEventTransition) 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.QKeyEventTransition_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 QKeyEventTransition that was directly constructed. +func (this *QKeyEventTransition) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QKeyEventTransition_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 *QKeyEventTransition) callVirtualBase_OnTransition(event *qt6.QEvent) { + + C.QKeyEventTransition_virtualbase_onTransition(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QKeyEventTransition) OnOnTransition(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QKeyEventTransition_override_virtual_onTransition(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QKeyEventTransition_onTransition +func miqt_exec_callback_QKeyEventTransition_onTransition(self *C.QKeyEventTransition, 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((&QKeyEventTransition{h: self}).callVirtualBase_OnTransition, slotval1) + +} + +func (this *QKeyEventTransition) callVirtualBase_EventTest(event *qt6.QEvent) bool { + + return (bool)(C.QKeyEventTransition_virtualbase_eventTest(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QKeyEventTransition) OnEventTest(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QKeyEventTransition_override_virtual_eventTest(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QKeyEventTransition_eventTest +func miqt_exec_callback_QKeyEventTransition_eventTest(self *C.QKeyEventTransition, 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((&QKeyEventTransition{h: self}).callVirtualBase_EventTest, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QKeyEventTransition) callVirtualBase_Event(e *qt6.QEvent) bool { + + return (bool)(C.QKeyEventTransition_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(e.UnsafePointer()))) + +} +func (this *QKeyEventTransition) OnEvent(slot func(super func(e *qt6.QEvent) bool, e *qt6.QEvent) bool) { + ok := C.QKeyEventTransition_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_QKeyEventTransition_event +func miqt_exec_callback_QKeyEventTransition_event(self *C.QKeyEventTransition, cb C.intptr_t, e *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(e *qt6.QEvent) bool, e *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(e)) + + virtualReturn := gofunc((&QKeyEventTransition{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QKeyEventTransition) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QKeyEventTransition_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QKeyEventTransition) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QKeyEventTransition_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_QKeyEventTransition_eventFilter +func miqt_exec_callback_QKeyEventTransition_eventFilter(self *C.QKeyEventTransition, 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((&QKeyEventTransition{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QKeyEventTransition) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QKeyEventTransition_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QKeyEventTransition) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QKeyEventTransition_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_QKeyEventTransition_timerEvent +func miqt_exec_callback_QKeyEventTransition_timerEvent(self *C.QKeyEventTransition, 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((&QKeyEventTransition{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QKeyEventTransition) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QKeyEventTransition_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QKeyEventTransition) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QKeyEventTransition_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_QKeyEventTransition_childEvent +func miqt_exec_callback_QKeyEventTransition_childEvent(self *C.QKeyEventTransition, 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((&QKeyEventTransition{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QKeyEventTransition) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QKeyEventTransition_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QKeyEventTransition) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QKeyEventTransition_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_QKeyEventTransition_customEvent +func miqt_exec_callback_QKeyEventTransition_customEvent(self *C.QKeyEventTransition, 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((&QKeyEventTransition{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QKeyEventTransition) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QKeyEventTransition_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QKeyEventTransition) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QKeyEventTransition_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_QKeyEventTransition_connectNotify +func miqt_exec_callback_QKeyEventTransition_connectNotify(self *C.QKeyEventTransition, 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((&QKeyEventTransition{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QKeyEventTransition) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QKeyEventTransition_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QKeyEventTransition) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QKeyEventTransition_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_QKeyEventTransition_disconnectNotify +func miqt_exec_callback_QKeyEventTransition_disconnectNotify(self *C.QKeyEventTransition, 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((&QKeyEventTransition{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QKeyEventTransition) Delete() { + C.QKeyEventTransition_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 *QKeyEventTransition) GoGC() { + runtime.SetFinalizer(this, func(this *QKeyEventTransition) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/statemachine/gen_qkeyeventtransition.h b/qt6/statemachine/gen_qkeyeventtransition.h new file mode 100644 index 000000000..6c2c13faf --- /dev/null +++ b/qt6/statemachine/gen_qkeyeventtransition.h @@ -0,0 +1,88 @@ +#pragma once +#ifndef MIQT_QT6_STATEMACHINE_GEN_QKEYEVENTTRANSITION_H +#define MIQT_QT6_STATEMACHINE_GEN_QKEYEVENTTRANSITION_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractTransition; +class QChildEvent; +class QEvent; +class QEventTransition; +class QKeyEventTransition; +class QMetaMethod; +class QMetaObject; +class QObject; +class QState; +class QTimerEvent; +#else +typedef struct QAbstractTransition QAbstractTransition; +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QEventTransition QEventTransition; +typedef struct QKeyEventTransition QKeyEventTransition; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QState QState; +typedef struct QTimerEvent QTimerEvent; +#endif + +QKeyEventTransition* QKeyEventTransition_new(); +QKeyEventTransition* QKeyEventTransition_new2(QObject* object, int type, int key); +QKeyEventTransition* QKeyEventTransition_new3(QState* sourceState); +QKeyEventTransition* QKeyEventTransition_new4(QObject* object, int type, int key, QState* sourceState); +void QKeyEventTransition_virtbase(QKeyEventTransition* src, QEventTransition** outptr_QEventTransition); +QMetaObject* QKeyEventTransition_metaObject(const QKeyEventTransition* self); +void* QKeyEventTransition_metacast(QKeyEventTransition* self, const char* param1); +struct miqt_string QKeyEventTransition_tr(const char* s); +int QKeyEventTransition_key(const QKeyEventTransition* self); +void QKeyEventTransition_setKey(QKeyEventTransition* self, int key); +int QKeyEventTransition_modifierMask(const QKeyEventTransition* self); +void QKeyEventTransition_setModifierMask(QKeyEventTransition* self, int modifiers); +void QKeyEventTransition_onTransition(QKeyEventTransition* self, QEvent* event); +bool QKeyEventTransition_eventTest(QKeyEventTransition* self, QEvent* event); +struct miqt_string QKeyEventTransition_tr2(const char* s, const char* c); +struct miqt_string QKeyEventTransition_tr3(const char* s, const char* c, int n); + +bool QKeyEventTransition_override_virtual_onTransition(void* self, intptr_t slot); +void QKeyEventTransition_virtualbase_onTransition(void* self, QEvent* event); +bool QKeyEventTransition_override_virtual_eventTest(void* self, intptr_t slot); +bool QKeyEventTransition_virtualbase_eventTest(void* self, QEvent* event); +bool QKeyEventTransition_override_virtual_event(void* self, intptr_t slot); +bool QKeyEventTransition_virtualbase_event(void* self, QEvent* e); +bool QKeyEventTransition_override_virtual_eventFilter(void* self, intptr_t slot); +bool QKeyEventTransition_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QKeyEventTransition_override_virtual_timerEvent(void* self, intptr_t slot); +void QKeyEventTransition_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QKeyEventTransition_override_virtual_childEvent(void* self, intptr_t slot); +void QKeyEventTransition_virtualbase_childEvent(void* self, QChildEvent* event); +bool QKeyEventTransition_override_virtual_customEvent(void* self, intptr_t slot); +void QKeyEventTransition_virtualbase_customEvent(void* self, QEvent* event); +bool QKeyEventTransition_override_virtual_connectNotify(void* self, intptr_t slot); +void QKeyEventTransition_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QKeyEventTransition_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QKeyEventTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QKeyEventTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QKeyEventTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QKeyEventTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QKeyEventTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QKeyEventTransition_delete(QKeyEventTransition* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/statemachine/gen_qmouseeventtransition.cpp b/qt6/statemachine/gen_qmouseeventtransition.cpp new file mode 100644 index 000000000..03fac7e71 --- /dev/null +++ b/qt6/statemachine/gen_qmouseeventtransition.cpp @@ -0,0 +1,467 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qmouseeventtransition.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QMouseEventTransition_onTransition(QMouseEventTransition*, intptr_t, QEvent*); +bool miqt_exec_callback_QMouseEventTransition_eventTest(QMouseEventTransition*, intptr_t, QEvent*); +bool miqt_exec_callback_QMouseEventTransition_event(QMouseEventTransition*, intptr_t, QEvent*); +bool miqt_exec_callback_QMouseEventTransition_eventFilter(QMouseEventTransition*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QMouseEventTransition_timerEvent(QMouseEventTransition*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QMouseEventTransition_childEvent(QMouseEventTransition*, intptr_t, QChildEvent*); +void miqt_exec_callback_QMouseEventTransition_customEvent(QMouseEventTransition*, intptr_t, QEvent*); +void miqt_exec_callback_QMouseEventTransition_connectNotify(QMouseEventTransition*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QMouseEventTransition_disconnectNotify(QMouseEventTransition*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQMouseEventTransition final : public QMouseEventTransition { +public: + + MiqtVirtualQMouseEventTransition(): QMouseEventTransition() {} + MiqtVirtualQMouseEventTransition(QObject* object, QEvent::Type type, Qt::MouseButton button): QMouseEventTransition(object, type, button) {} + MiqtVirtualQMouseEventTransition(QState* sourceState): QMouseEventTransition(sourceState) {} + MiqtVirtualQMouseEventTransition(QObject* object, QEvent::Type type, Qt::MouseButton button, QState* sourceState): QMouseEventTransition(object, type, button, sourceState) {} + + virtual ~MiqtVirtualQMouseEventTransition() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__onTransition = 0; + + // Subclass to allow providing a Go implementation + virtual void onTransition(QEvent* event) override { + if (handle__onTransition == 0) { + QMouseEventTransition::onTransition(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QMouseEventTransition_onTransition(this, handle__onTransition, sigval1); + + } + + friend void QMouseEventTransition_virtualbase_onTransition(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventTest = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventTest(QEvent* event) override { + if (handle__eventTest == 0) { + return QMouseEventTransition::eventTest(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QMouseEventTransition_eventTest(this, handle__eventTest, sigval1); + return callback_return_value; + } + + friend bool QMouseEventTransition_virtualbase_eventTest(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* e) override { + if (handle__event == 0) { + return QMouseEventTransition::event(e); + } + + QEvent* sigval1 = e; + bool callback_return_value = miqt_exec_callback_QMouseEventTransition_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QMouseEventTransition_virtualbase_event(void* self, QEvent* e); + + // 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 QMouseEventTransition::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QMouseEventTransition_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QMouseEventTransition_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) { + QMouseEventTransition::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QMouseEventTransition_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QMouseEventTransition_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) { + QMouseEventTransition::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QMouseEventTransition_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QMouseEventTransition_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) { + QMouseEventTransition::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QMouseEventTransition_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QMouseEventTransition_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) { + QMouseEventTransition::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QMouseEventTransition_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QMouseEventTransition_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) { + QMouseEventTransition::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QMouseEventTransition_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QMouseEventTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QMouseEventTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QMouseEventTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QMouseEventTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QMouseEventTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QMouseEventTransition* QMouseEventTransition_new() { + return new (std::nothrow) MiqtVirtualQMouseEventTransition(); +} + +QMouseEventTransition* QMouseEventTransition_new2(QObject* object, int type, int button) { + return new (std::nothrow) MiqtVirtualQMouseEventTransition(object, static_cast(type), static_cast(button)); +} + +QMouseEventTransition* QMouseEventTransition_new3(QState* sourceState) { + return new (std::nothrow) MiqtVirtualQMouseEventTransition(sourceState); +} + +QMouseEventTransition* QMouseEventTransition_new4(QObject* object, int type, int button, QState* sourceState) { + return new (std::nothrow) MiqtVirtualQMouseEventTransition(object, static_cast(type), static_cast(button), sourceState); +} + +void QMouseEventTransition_virtbase(QMouseEventTransition* src, QEventTransition** outptr_QEventTransition) { + *outptr_QEventTransition = static_cast(src); +} + +QMetaObject* QMouseEventTransition_metaObject(const QMouseEventTransition* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QMouseEventTransition_metacast(QMouseEventTransition* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QMouseEventTransition_tr(const char* s) { + QString _ret = QMouseEventTransition::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 QMouseEventTransition_button(const QMouseEventTransition* self) { + Qt::MouseButton _ret = self->button(); + return static_cast(_ret); +} + +void QMouseEventTransition_setButton(QMouseEventTransition* self, int button) { + self->setButton(static_cast(button)); +} + +int QMouseEventTransition_modifierMask(const QMouseEventTransition* self) { + Qt::KeyboardModifiers _ret = self->modifierMask(); + return static_cast(_ret); +} + +void QMouseEventTransition_setModifierMask(QMouseEventTransition* self, int modifiers) { + self->setModifierMask(static_cast(modifiers)); +} + +QPainterPath* QMouseEventTransition_hitTestPath(const QMouseEventTransition* self) { + return new QPainterPath(self->hitTestPath()); +} + +void QMouseEventTransition_setHitTestPath(QMouseEventTransition* self, QPainterPath* path) { + self->setHitTestPath(*path); +} + +struct miqt_string QMouseEventTransition_tr2(const char* s, const char* c) { + QString _ret = QMouseEventTransition::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 QMouseEventTransition_tr3(const char* s, const char* c, int n) { + QString _ret = QMouseEventTransition::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 QMouseEventTransition_override_virtual_onTransition(void* self, intptr_t slot) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onTransition = slot; + return true; +} + +void QMouseEventTransition_virtualbase_onTransition(void* self, QEvent* event) { + static_cast(self)->QMouseEventTransition::onTransition(event); +} + +bool QMouseEventTransition_override_virtual_eventTest(void* self, intptr_t slot) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventTest = slot; + return true; +} + +bool QMouseEventTransition_virtualbase_eventTest(void* self, QEvent* event) { + return static_cast(self)->QMouseEventTransition::eventTest(event); +} + +bool QMouseEventTransition_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QMouseEventTransition_virtualbase_event(void* self, QEvent* e) { + return static_cast(self)->QMouseEventTransition::event(e); +} + +bool QMouseEventTransition_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QMouseEventTransition_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QMouseEventTransition::eventFilter(watched, event); +} + +bool QMouseEventTransition_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QMouseEventTransition_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QMouseEventTransition::timerEvent(event); +} + +bool QMouseEventTransition_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QMouseEventTransition_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QMouseEventTransition::childEvent(event); +} + +bool QMouseEventTransition_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QMouseEventTransition_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QMouseEventTransition::customEvent(event); +} + +bool QMouseEventTransition_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QMouseEventTransition_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QMouseEventTransition::connectNotify(*signal); +} + +bool QMouseEventTransition_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QMouseEventTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QMouseEventTransition::disconnectNotify(*signal); +} + +QObject* QMouseEventTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QMouseEventTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QMouseEventTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QMouseEventTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQMouseEventTransition* self_cast = dynamic_cast( (QMouseEventTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QMouseEventTransition_delete(QMouseEventTransition* self) { + delete self; +} + diff --git a/qt6/statemachine/gen_qmouseeventtransition.go b/qt6/statemachine/gen_qmouseeventtransition.go new file mode 100644 index 000000000..9d39bc3da --- /dev/null +++ b/qt6/statemachine/gen_qmouseeventtransition.go @@ -0,0 +1,457 @@ +package statemachine + +/* + +#include "gen_qmouseeventtransition.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QMouseEventTransition struct { + h *C.QMouseEventTransition + *QEventTransition +} + +func (this *QMouseEventTransition) cPointer() *C.QMouseEventTransition { + if this == nil { + return nil + } + return this.h +} + +func (this *QMouseEventTransition) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQMouseEventTransition constructs the type using only CGO pointers. +func newQMouseEventTransition(h *C.QMouseEventTransition) *QMouseEventTransition { + if h == nil { + return nil + } + var outptr_QEventTransition *C.QEventTransition = nil + C.QMouseEventTransition_virtbase(h, &outptr_QEventTransition) + + return &QMouseEventTransition{h: h, + QEventTransition: newQEventTransition(outptr_QEventTransition)} +} + +// UnsafeNewQMouseEventTransition constructs the type using only unsafe pointers. +func UnsafeNewQMouseEventTransition(h unsafe.Pointer) *QMouseEventTransition { + return newQMouseEventTransition((*C.QMouseEventTransition)(h)) +} + +// NewQMouseEventTransition constructs a new QMouseEventTransition object. +func NewQMouseEventTransition() *QMouseEventTransition { + + return newQMouseEventTransition(C.QMouseEventTransition_new()) +} + +// NewQMouseEventTransition2 constructs a new QMouseEventTransition object. +func NewQMouseEventTransition2(object *qt6.QObject, typeVal qt6.QEvent__Type, button qt6.MouseButton) *QMouseEventTransition { + + return newQMouseEventTransition(C.QMouseEventTransition_new2((*C.QObject)(object.UnsafePointer()), (C.int)(typeVal), (C.int)(button))) +} + +// NewQMouseEventTransition3 constructs a new QMouseEventTransition object. +func NewQMouseEventTransition3(sourceState *QState) *QMouseEventTransition { + + return newQMouseEventTransition(C.QMouseEventTransition_new3(sourceState.cPointer())) +} + +// NewQMouseEventTransition4 constructs a new QMouseEventTransition object. +func NewQMouseEventTransition4(object *qt6.QObject, typeVal qt6.QEvent__Type, button qt6.MouseButton, sourceState *QState) *QMouseEventTransition { + + return newQMouseEventTransition(C.QMouseEventTransition_new4((*C.QObject)(object.UnsafePointer()), (C.int)(typeVal), (C.int)(button), sourceState.cPointer())) +} + +func (this *QMouseEventTransition) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QMouseEventTransition_metaObject(this.h))) +} + +func (this *QMouseEventTransition) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QMouseEventTransition_metacast(this.h, param1_Cstring)) +} + +func QMouseEventTransition_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QMouseEventTransition_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QMouseEventTransition) Button() qt6.MouseButton { + return (qt6.MouseButton)(C.QMouseEventTransition_button(this.h)) +} + +func (this *QMouseEventTransition) SetButton(button qt6.MouseButton) { + C.QMouseEventTransition_setButton(this.h, (C.int)(button)) +} + +func (this *QMouseEventTransition) ModifierMask() qt6.KeyboardModifier { + return (qt6.KeyboardModifier)(C.QMouseEventTransition_modifierMask(this.h)) +} + +func (this *QMouseEventTransition) SetModifierMask(modifiers qt6.KeyboardModifier) { + C.QMouseEventTransition_setModifierMask(this.h, (C.int)(modifiers)) +} + +func (this *QMouseEventTransition) HitTestPath() *qt6.QPainterPath { + _goptr := qt6.UnsafeNewQPainterPath(unsafe.Pointer(C.QMouseEventTransition_hitTestPath(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QMouseEventTransition) SetHitTestPath(path *qt6.QPainterPath) { + C.QMouseEventTransition_setHitTestPath(this.h, (*C.QPainterPath)(path.UnsafePointer())) +} + +func QMouseEventTransition_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.QMouseEventTransition_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QMouseEventTransition_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.QMouseEventTransition_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 +} + +// Sender can only be called from a QMouseEventTransition that was directly constructed. +func (this *QMouseEventTransition) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QMouseEventTransition_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 QMouseEventTransition that was directly constructed. +func (this *QMouseEventTransition) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QMouseEventTransition_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 QMouseEventTransition that was directly constructed. +func (this *QMouseEventTransition) 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.QMouseEventTransition_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 QMouseEventTransition that was directly constructed. +func (this *QMouseEventTransition) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QMouseEventTransition_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 *QMouseEventTransition) callVirtualBase_OnTransition(event *qt6.QEvent) { + + C.QMouseEventTransition_virtualbase_onTransition(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QMouseEventTransition) OnOnTransition(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QMouseEventTransition_override_virtual_onTransition(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QMouseEventTransition_onTransition +func miqt_exec_callback_QMouseEventTransition_onTransition(self *C.QMouseEventTransition, 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((&QMouseEventTransition{h: self}).callVirtualBase_OnTransition, slotval1) + +} + +func (this *QMouseEventTransition) callVirtualBase_EventTest(event *qt6.QEvent) bool { + + return (bool)(C.QMouseEventTransition_virtualbase_eventTest(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QMouseEventTransition) OnEventTest(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QMouseEventTransition_override_virtual_eventTest(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QMouseEventTransition_eventTest +func miqt_exec_callback_QMouseEventTransition_eventTest(self *C.QMouseEventTransition, 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((&QMouseEventTransition{h: self}).callVirtualBase_EventTest, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QMouseEventTransition) callVirtualBase_Event(e *qt6.QEvent) bool { + + return (bool)(C.QMouseEventTransition_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(e.UnsafePointer()))) + +} +func (this *QMouseEventTransition) OnEvent(slot func(super func(e *qt6.QEvent) bool, e *qt6.QEvent) bool) { + ok := C.QMouseEventTransition_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_QMouseEventTransition_event +func miqt_exec_callback_QMouseEventTransition_event(self *C.QMouseEventTransition, cb C.intptr_t, e *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(e *qt6.QEvent) bool, e *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(e)) + + virtualReturn := gofunc((&QMouseEventTransition{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QMouseEventTransition) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QMouseEventTransition_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QMouseEventTransition) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QMouseEventTransition_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_QMouseEventTransition_eventFilter +func miqt_exec_callback_QMouseEventTransition_eventFilter(self *C.QMouseEventTransition, 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((&QMouseEventTransition{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QMouseEventTransition) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QMouseEventTransition_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QMouseEventTransition) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QMouseEventTransition_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_QMouseEventTransition_timerEvent +func miqt_exec_callback_QMouseEventTransition_timerEvent(self *C.QMouseEventTransition, 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((&QMouseEventTransition{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QMouseEventTransition) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QMouseEventTransition_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QMouseEventTransition) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QMouseEventTransition_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_QMouseEventTransition_childEvent +func miqt_exec_callback_QMouseEventTransition_childEvent(self *C.QMouseEventTransition, 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((&QMouseEventTransition{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QMouseEventTransition) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QMouseEventTransition_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QMouseEventTransition) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QMouseEventTransition_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_QMouseEventTransition_customEvent +func miqt_exec_callback_QMouseEventTransition_customEvent(self *C.QMouseEventTransition, 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((&QMouseEventTransition{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QMouseEventTransition) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QMouseEventTransition_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QMouseEventTransition) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QMouseEventTransition_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_QMouseEventTransition_connectNotify +func miqt_exec_callback_QMouseEventTransition_connectNotify(self *C.QMouseEventTransition, 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((&QMouseEventTransition{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QMouseEventTransition) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QMouseEventTransition_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QMouseEventTransition) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QMouseEventTransition_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_QMouseEventTransition_disconnectNotify +func miqt_exec_callback_QMouseEventTransition_disconnectNotify(self *C.QMouseEventTransition, 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((&QMouseEventTransition{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QMouseEventTransition) Delete() { + C.QMouseEventTransition_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 *QMouseEventTransition) GoGC() { + runtime.SetFinalizer(this, func(this *QMouseEventTransition) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/statemachine/gen_qmouseeventtransition.h b/qt6/statemachine/gen_qmouseeventtransition.h new file mode 100644 index 000000000..dc1535cfc --- /dev/null +++ b/qt6/statemachine/gen_qmouseeventtransition.h @@ -0,0 +1,92 @@ +#pragma once +#ifndef MIQT_QT6_STATEMACHINE_GEN_QMOUSEEVENTTRANSITION_H +#define MIQT_QT6_STATEMACHINE_GEN_QMOUSEEVENTTRANSITION_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractTransition; +class QChildEvent; +class QEvent; +class QEventTransition; +class QMetaMethod; +class QMetaObject; +class QMouseEventTransition; +class QObject; +class QPainterPath; +class QState; +class QTimerEvent; +#else +typedef struct QAbstractTransition QAbstractTransition; +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QEventTransition QEventTransition; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QMouseEventTransition QMouseEventTransition; +typedef struct QObject QObject; +typedef struct QPainterPath QPainterPath; +typedef struct QState QState; +typedef struct QTimerEvent QTimerEvent; +#endif + +QMouseEventTransition* QMouseEventTransition_new(); +QMouseEventTransition* QMouseEventTransition_new2(QObject* object, int type, int button); +QMouseEventTransition* QMouseEventTransition_new3(QState* sourceState); +QMouseEventTransition* QMouseEventTransition_new4(QObject* object, int type, int button, QState* sourceState); +void QMouseEventTransition_virtbase(QMouseEventTransition* src, QEventTransition** outptr_QEventTransition); +QMetaObject* QMouseEventTransition_metaObject(const QMouseEventTransition* self); +void* QMouseEventTransition_metacast(QMouseEventTransition* self, const char* param1); +struct miqt_string QMouseEventTransition_tr(const char* s); +int QMouseEventTransition_button(const QMouseEventTransition* self); +void QMouseEventTransition_setButton(QMouseEventTransition* self, int button); +int QMouseEventTransition_modifierMask(const QMouseEventTransition* self); +void QMouseEventTransition_setModifierMask(QMouseEventTransition* self, int modifiers); +QPainterPath* QMouseEventTransition_hitTestPath(const QMouseEventTransition* self); +void QMouseEventTransition_setHitTestPath(QMouseEventTransition* self, QPainterPath* path); +void QMouseEventTransition_onTransition(QMouseEventTransition* self, QEvent* event); +bool QMouseEventTransition_eventTest(QMouseEventTransition* self, QEvent* event); +struct miqt_string QMouseEventTransition_tr2(const char* s, const char* c); +struct miqt_string QMouseEventTransition_tr3(const char* s, const char* c, int n); + +bool QMouseEventTransition_override_virtual_onTransition(void* self, intptr_t slot); +void QMouseEventTransition_virtualbase_onTransition(void* self, QEvent* event); +bool QMouseEventTransition_override_virtual_eventTest(void* self, intptr_t slot); +bool QMouseEventTransition_virtualbase_eventTest(void* self, QEvent* event); +bool QMouseEventTransition_override_virtual_event(void* self, intptr_t slot); +bool QMouseEventTransition_virtualbase_event(void* self, QEvent* e); +bool QMouseEventTransition_override_virtual_eventFilter(void* self, intptr_t slot); +bool QMouseEventTransition_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QMouseEventTransition_override_virtual_timerEvent(void* self, intptr_t slot); +void QMouseEventTransition_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QMouseEventTransition_override_virtual_childEvent(void* self, intptr_t slot); +void QMouseEventTransition_virtualbase_childEvent(void* self, QChildEvent* event); +bool QMouseEventTransition_override_virtual_customEvent(void* self, intptr_t slot); +void QMouseEventTransition_virtualbase_customEvent(void* self, QEvent* event); +bool QMouseEventTransition_override_virtual_connectNotify(void* self, intptr_t slot); +void QMouseEventTransition_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QMouseEventTransition_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QMouseEventTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QMouseEventTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QMouseEventTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QMouseEventTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QMouseEventTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QMouseEventTransition_delete(QMouseEventTransition* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/statemachine/gen_qsignaltransition.cpp b/qt6/statemachine/gen_qsignaltransition.cpp new file mode 100644 index 000000000..239048e5c --- /dev/null +++ b/qt6/statemachine/gen_qsignaltransition.cpp @@ -0,0 +1,476 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qsignaltransition.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QSignalTransition_senderObjectChanged(intptr_t); +void miqt_exec_callback_QSignalTransition_signalChanged(intptr_t); +bool miqt_exec_callback_QSignalTransition_eventTest(QSignalTransition*, intptr_t, QEvent*); +void miqt_exec_callback_QSignalTransition_onTransition(QSignalTransition*, intptr_t, QEvent*); +bool miqt_exec_callback_QSignalTransition_event(QSignalTransition*, intptr_t, QEvent*); +bool miqt_exec_callback_QSignalTransition_eventFilter(QSignalTransition*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QSignalTransition_timerEvent(QSignalTransition*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QSignalTransition_childEvent(QSignalTransition*, intptr_t, QChildEvent*); +void miqt_exec_callback_QSignalTransition_customEvent(QSignalTransition*, intptr_t, QEvent*); +void miqt_exec_callback_QSignalTransition_connectNotify(QSignalTransition*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QSignalTransition_disconnectNotify(QSignalTransition*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQSignalTransition final : public QSignalTransition { +public: + + MiqtVirtualQSignalTransition(): QSignalTransition() {} + MiqtVirtualQSignalTransition(const QObject* sender, const char* signal): QSignalTransition(sender, signal) {} + MiqtVirtualQSignalTransition(QState* sourceState): QSignalTransition(sourceState) {} + MiqtVirtualQSignalTransition(const QObject* sender, const char* signal, QState* sourceState): QSignalTransition(sender, signal, sourceState) {} + + virtual ~MiqtVirtualQSignalTransition() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventTest = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventTest(QEvent* event) override { + if (handle__eventTest == 0) { + return QSignalTransition::eventTest(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QSignalTransition_eventTest(this, handle__eventTest, sigval1); + return callback_return_value; + } + + friend bool QSignalTransition_virtualbase_eventTest(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__onTransition = 0; + + // Subclass to allow providing a Go implementation + virtual void onTransition(QEvent* event) override { + if (handle__onTransition == 0) { + QSignalTransition::onTransition(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QSignalTransition_onTransition(this, handle__onTransition, sigval1); + + } + + friend void QSignalTransition_virtualbase_onTransition(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* e) override { + if (handle__event == 0) { + return QSignalTransition::event(e); + } + + QEvent* sigval1 = e; + bool callback_return_value = miqt_exec_callback_QSignalTransition_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QSignalTransition_virtualbase_event(void* self, QEvent* e); + + // 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 QSignalTransition::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QSignalTransition_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QSignalTransition_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) { + QSignalTransition::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QSignalTransition_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QSignalTransition_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) { + QSignalTransition::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QSignalTransition_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QSignalTransition_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) { + QSignalTransition::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QSignalTransition_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QSignalTransition_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) { + QSignalTransition::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QSignalTransition_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QSignalTransition_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) { + QSignalTransition::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QSignalTransition_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QSignalTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QSignalTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QSignalTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QSignalTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QSignalTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QSignalTransition* QSignalTransition_new() { + return new (std::nothrow) MiqtVirtualQSignalTransition(); +} + +QSignalTransition* QSignalTransition_new2(QObject* sender, const char* signal) { + return new (std::nothrow) MiqtVirtualQSignalTransition(sender, signal); +} + +QSignalTransition* QSignalTransition_new3(QState* sourceState) { + return new (std::nothrow) MiqtVirtualQSignalTransition(sourceState); +} + +QSignalTransition* QSignalTransition_new4(QObject* sender, const char* signal, QState* sourceState) { + return new (std::nothrow) MiqtVirtualQSignalTransition(sender, signal, sourceState); +} + +void QSignalTransition_virtbase(QSignalTransition* src, QAbstractTransition** outptr_QAbstractTransition) { + *outptr_QAbstractTransition = static_cast(src); +} + +QMetaObject* QSignalTransition_metaObject(const QSignalTransition* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QSignalTransition_metacast(QSignalTransition* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QSignalTransition_tr(const char* s) { + QString _ret = QSignalTransition::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; +} + +QObject* QSignalTransition_senderObject(const QSignalTransition* self) { + return (QObject*) self->senderObject(); +} + +void QSignalTransition_setSenderObject(QSignalTransition* self, QObject* sender) { + self->setSenderObject(sender); +} + +struct miqt_string QSignalTransition_signal(const QSignalTransition* self) { + QByteArray _qb = self->signal(); + struct miqt_string _ms; + _ms.len = _qb.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _qb.data(), _ms.len); + return _ms; +} + +void QSignalTransition_setSignal(QSignalTransition* self, struct miqt_string signal) { + QByteArray signal_QByteArray(signal.data, signal.len); + self->setSignal(signal_QByteArray); +} + +struct miqt_string QSignalTransition_tr2(const char* s, const char* c) { + QString _ret = QSignalTransition::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 QSignalTransition_tr3(const char* s, const char* c, int n) { + QString _ret = QSignalTransition::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 QSignalTransition_override_virtual_eventTest(void* self, intptr_t slot) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventTest = slot; + return true; +} + +bool QSignalTransition_virtualbase_eventTest(void* self, QEvent* event) { + return static_cast(self)->QSignalTransition::eventTest(event); +} + +bool QSignalTransition_override_virtual_onTransition(void* self, intptr_t slot) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onTransition = slot; + return true; +} + +void QSignalTransition_virtualbase_onTransition(void* self, QEvent* event) { + static_cast(self)->QSignalTransition::onTransition(event); +} + +bool QSignalTransition_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QSignalTransition_virtualbase_event(void* self, QEvent* e) { + return static_cast(self)->QSignalTransition::event(e); +} + +bool QSignalTransition_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QSignalTransition_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QSignalTransition::eventFilter(watched, event); +} + +bool QSignalTransition_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QSignalTransition_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QSignalTransition::timerEvent(event); +} + +bool QSignalTransition_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QSignalTransition_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QSignalTransition::childEvent(event); +} + +bool QSignalTransition_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QSignalTransition_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QSignalTransition::customEvent(event); +} + +bool QSignalTransition_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QSignalTransition_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QSignalTransition::connectNotify(*signal); +} + +bool QSignalTransition_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QSignalTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QSignalTransition::disconnectNotify(*signal); +} + +QObject* QSignalTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QSignalTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QSignalTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QSignalTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQSignalTransition* self_cast = dynamic_cast( (QSignalTransition*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QSignalTransition_connect_senderObjectChanged(QSignalTransition* self, intptr_t slot) { + QSignalTransition::connect(self, &QSignalTransition::senderObjectChanged, self, [=]() { + miqt_exec_callback_QSignalTransition_senderObjectChanged(slot); + }); +} + +void QSignalTransition_connect_signalChanged(QSignalTransition* self, intptr_t slot) { + QSignalTransition::connect(self, &QSignalTransition::signalChanged, self, [=]() { + miqt_exec_callback_QSignalTransition_signalChanged(slot); + }); +} + +void QSignalTransition_delete(QSignalTransition* self) { + delete self; +} + diff --git a/qt6/statemachine/gen_qsignaltransition.go b/qt6/statemachine/gen_qsignaltransition.go new file mode 100644 index 000000000..ed09bc79a --- /dev/null +++ b/qt6/statemachine/gen_qsignaltransition.go @@ -0,0 +1,488 @@ +package statemachine + +/* + +#include "gen_qsignaltransition.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QSignalTransition struct { + h *C.QSignalTransition + *QAbstractTransition +} + +func (this *QSignalTransition) cPointer() *C.QSignalTransition { + if this == nil { + return nil + } + return this.h +} + +func (this *QSignalTransition) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQSignalTransition constructs the type using only CGO pointers. +func newQSignalTransition(h *C.QSignalTransition) *QSignalTransition { + if h == nil { + return nil + } + var outptr_QAbstractTransition *C.QAbstractTransition = nil + C.QSignalTransition_virtbase(h, &outptr_QAbstractTransition) + + return &QSignalTransition{h: h, + QAbstractTransition: newQAbstractTransition(outptr_QAbstractTransition)} +} + +// UnsafeNewQSignalTransition constructs the type using only unsafe pointers. +func UnsafeNewQSignalTransition(h unsafe.Pointer) *QSignalTransition { + return newQSignalTransition((*C.QSignalTransition)(h)) +} + +// NewQSignalTransition constructs a new QSignalTransition object. +func NewQSignalTransition() *QSignalTransition { + + return newQSignalTransition(C.QSignalTransition_new()) +} + +// NewQSignalTransition2 constructs a new QSignalTransition object. +func NewQSignalTransition2(sender *qt6.QObject, signal string) *QSignalTransition { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + return newQSignalTransition(C.QSignalTransition_new2((*C.QObject)(sender.UnsafePointer()), signal_Cstring)) +} + +// NewQSignalTransition3 constructs a new QSignalTransition object. +func NewQSignalTransition3(sourceState *QState) *QSignalTransition { + + return newQSignalTransition(C.QSignalTransition_new3(sourceState.cPointer())) +} + +// NewQSignalTransition4 constructs a new QSignalTransition object. +func NewQSignalTransition4(sender *qt6.QObject, signal string, sourceState *QState) *QSignalTransition { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + + return newQSignalTransition(C.QSignalTransition_new4((*C.QObject)(sender.UnsafePointer()), signal_Cstring, sourceState.cPointer())) +} + +func (this *QSignalTransition) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QSignalTransition_metaObject(this.h))) +} + +func (this *QSignalTransition) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QSignalTransition_metacast(this.h, param1_Cstring)) +} + +func QSignalTransition_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QSignalTransition_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QSignalTransition) SenderObject() *qt6.QObject { + return qt6.UnsafeNewQObject(unsafe.Pointer(C.QSignalTransition_senderObject(this.h))) +} + +func (this *QSignalTransition) SetSenderObject(sender *qt6.QObject) { + C.QSignalTransition_setSenderObject(this.h, (*C.QObject)(sender.UnsafePointer())) +} + +func (this *QSignalTransition) Signal() []byte { + var _bytearray C.struct_miqt_string = C.QSignalTransition_signal(this.h) + _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) + C.free(unsafe.Pointer(_bytearray.data)) + return _ret +} + +func (this *QSignalTransition) SetSignal(signal []byte) { + signal_alias := C.struct_miqt_string{} + if len(signal) > 0 { + signal_alias.data = (*C.char)(unsafe.Pointer(&signal[0])) + } else { + signal_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + signal_alias.len = C.size_t(len(signal)) + C.QSignalTransition_setSignal(this.h, signal_alias) +} + +func QSignalTransition_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.QSignalTransition_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QSignalTransition_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.QSignalTransition_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 +} + +// Sender can only be called from a QSignalTransition that was directly constructed. +func (this *QSignalTransition) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QSignalTransition_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 QSignalTransition that was directly constructed. +func (this *QSignalTransition) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QSignalTransition_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 QSignalTransition that was directly constructed. +func (this *QSignalTransition) 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.QSignalTransition_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 QSignalTransition that was directly constructed. +func (this *QSignalTransition) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QSignalTransition_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 *QSignalTransition) callVirtualBase_EventTest(event *qt6.QEvent) bool { + + return (bool)(C.QSignalTransition_virtualbase_eventTest(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QSignalTransition) OnEventTest(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QSignalTransition_override_virtual_eventTest(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QSignalTransition_eventTest +func miqt_exec_callback_QSignalTransition_eventTest(self *C.QSignalTransition, 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((&QSignalTransition{h: self}).callVirtualBase_EventTest, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QSignalTransition) callVirtualBase_OnTransition(event *qt6.QEvent) { + + C.QSignalTransition_virtualbase_onTransition(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QSignalTransition) OnOnTransition(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QSignalTransition_override_virtual_onTransition(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QSignalTransition_onTransition +func miqt_exec_callback_QSignalTransition_onTransition(self *C.QSignalTransition, 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((&QSignalTransition{h: self}).callVirtualBase_OnTransition, slotval1) + +} + +func (this *QSignalTransition) callVirtualBase_Event(e *qt6.QEvent) bool { + + return (bool)(C.QSignalTransition_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(e.UnsafePointer()))) + +} +func (this *QSignalTransition) OnEvent(slot func(super func(e *qt6.QEvent) bool, e *qt6.QEvent) bool) { + ok := C.QSignalTransition_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_QSignalTransition_event +func miqt_exec_callback_QSignalTransition_event(self *C.QSignalTransition, cb C.intptr_t, e *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(e *qt6.QEvent) bool, e *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(e)) + + virtualReturn := gofunc((&QSignalTransition{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QSignalTransition) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QSignalTransition_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QSignalTransition) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QSignalTransition_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_QSignalTransition_eventFilter +func miqt_exec_callback_QSignalTransition_eventFilter(self *C.QSignalTransition, 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((&QSignalTransition{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QSignalTransition) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QSignalTransition_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QSignalTransition) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QSignalTransition_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_QSignalTransition_timerEvent +func miqt_exec_callback_QSignalTransition_timerEvent(self *C.QSignalTransition, 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((&QSignalTransition{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QSignalTransition) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QSignalTransition_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QSignalTransition) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QSignalTransition_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_QSignalTransition_childEvent +func miqt_exec_callback_QSignalTransition_childEvent(self *C.QSignalTransition, 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((&QSignalTransition{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QSignalTransition) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QSignalTransition_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QSignalTransition) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QSignalTransition_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_QSignalTransition_customEvent +func miqt_exec_callback_QSignalTransition_customEvent(self *C.QSignalTransition, 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((&QSignalTransition{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QSignalTransition) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QSignalTransition_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QSignalTransition) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QSignalTransition_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_QSignalTransition_connectNotify +func miqt_exec_callback_QSignalTransition_connectNotify(self *C.QSignalTransition, 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((&QSignalTransition{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QSignalTransition) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QSignalTransition_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QSignalTransition) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QSignalTransition_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_QSignalTransition_disconnectNotify +func miqt_exec_callback_QSignalTransition_disconnectNotify(self *C.QSignalTransition, 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((&QSignalTransition{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} +func (this *QSignalTransition) OnSenderObjectChanged(slot func()) { + C.QSignalTransition_connect_senderObjectChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QSignalTransition_senderObjectChanged +func miqt_exec_callback_QSignalTransition_senderObjectChanged(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 *QSignalTransition) OnSignalChanged(slot func()) { + C.QSignalTransition_connect_signalChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QSignalTransition_signalChanged +func miqt_exec_callback_QSignalTransition_signalChanged(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +// Delete this object from C++ memory. +func (this *QSignalTransition) Delete() { + C.QSignalTransition_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 *QSignalTransition) GoGC() { + runtime.SetFinalizer(this, func(this *QSignalTransition) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/statemachine/gen_qsignaltransition.h b/qt6/statemachine/gen_qsignaltransition.h new file mode 100644 index 000000000..7e97bbf56 --- /dev/null +++ b/qt6/statemachine/gen_qsignaltransition.h @@ -0,0 +1,90 @@ +#pragma once +#ifndef MIQT_QT6_STATEMACHINE_GEN_QSIGNALTRANSITION_H +#define MIQT_QT6_STATEMACHINE_GEN_QSIGNALTRANSITION_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractTransition; +class QChildEvent; +class QEvent; +class QMetaMethod; +class QMetaObject; +class QObject; +class QSignalTransition; +class QState; +class QTimerEvent; +#else +typedef struct QAbstractTransition QAbstractTransition; +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QSignalTransition QSignalTransition; +typedef struct QState QState; +typedef struct QTimerEvent QTimerEvent; +#endif + +QSignalTransition* QSignalTransition_new(); +QSignalTransition* QSignalTransition_new2(QObject* sender, const char* signal); +QSignalTransition* QSignalTransition_new3(QState* sourceState); +QSignalTransition* QSignalTransition_new4(QObject* sender, const char* signal, QState* sourceState); +void QSignalTransition_virtbase(QSignalTransition* src, QAbstractTransition** outptr_QAbstractTransition); +QMetaObject* QSignalTransition_metaObject(const QSignalTransition* self); +void* QSignalTransition_metacast(QSignalTransition* self, const char* param1); +struct miqt_string QSignalTransition_tr(const char* s); +QObject* QSignalTransition_senderObject(const QSignalTransition* self); +void QSignalTransition_setSenderObject(QSignalTransition* self, QObject* sender); +struct miqt_string QSignalTransition_signal(const QSignalTransition* self); +void QSignalTransition_setSignal(QSignalTransition* self, struct miqt_string signal); +bool QSignalTransition_eventTest(QSignalTransition* self, QEvent* event); +void QSignalTransition_onTransition(QSignalTransition* self, QEvent* event); +bool QSignalTransition_event(QSignalTransition* self, QEvent* e); +struct miqt_string QSignalTransition_tr2(const char* s, const char* c); +struct miqt_string QSignalTransition_tr3(const char* s, const char* c, int n); + +bool QSignalTransition_override_virtual_eventTest(void* self, intptr_t slot); +bool QSignalTransition_virtualbase_eventTest(void* self, QEvent* event); +bool QSignalTransition_override_virtual_onTransition(void* self, intptr_t slot); +void QSignalTransition_virtualbase_onTransition(void* self, QEvent* event); +bool QSignalTransition_override_virtual_event(void* self, intptr_t slot); +bool QSignalTransition_virtualbase_event(void* self, QEvent* e); +bool QSignalTransition_override_virtual_eventFilter(void* self, intptr_t slot); +bool QSignalTransition_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QSignalTransition_override_virtual_timerEvent(void* self, intptr_t slot); +void QSignalTransition_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QSignalTransition_override_virtual_childEvent(void* self, intptr_t slot); +void QSignalTransition_virtualbase_childEvent(void* self, QChildEvent* event); +bool QSignalTransition_override_virtual_customEvent(void* self, intptr_t slot); +void QSignalTransition_virtualbase_customEvent(void* self, QEvent* event); +bool QSignalTransition_override_virtual_connectNotify(void* self, intptr_t slot); +void QSignalTransition_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QSignalTransition_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QSignalTransition_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QSignalTransition_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QSignalTransition_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QSignalTransition_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QSignalTransition_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QSignalTransition_connect_senderObjectChanged(QSignalTransition* self, intptr_t slot); +void QSignalTransition_connect_signalChanged(QSignalTransition* self, intptr_t slot); + +void QSignalTransition_delete(QSignalTransition* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/statemachine/gen_qstate.cpp b/qt6/statemachine/gen_qstate.cpp new file mode 100644 index 000000000..5c6d3db16 --- /dev/null +++ b/qt6/statemachine/gen_qstate.cpp @@ -0,0 +1,536 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qstate.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QState_finished(intptr_t); +void miqt_exec_callback_QState_propertiesAssigned(intptr_t); +void miqt_exec_callback_QState_childModeChanged(intptr_t); +void miqt_exec_callback_QState_initialStateChanged(intptr_t); +void miqt_exec_callback_QState_errorStateChanged(intptr_t); +void miqt_exec_callback_QState_onEntry(QState*, intptr_t, QEvent*); +void miqt_exec_callback_QState_onExit(QState*, intptr_t, QEvent*); +bool miqt_exec_callback_QState_event(QState*, intptr_t, QEvent*); +bool miqt_exec_callback_QState_eventFilter(QState*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QState_timerEvent(QState*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QState_childEvent(QState*, intptr_t, QChildEvent*); +void miqt_exec_callback_QState_customEvent(QState*, intptr_t, QEvent*); +void miqt_exec_callback_QState_connectNotify(QState*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QState_disconnectNotify(QState*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQState final : public QState { +public: + + MiqtVirtualQState(): QState() {} + MiqtVirtualQState(QState::ChildMode childMode): QState(childMode) {} + MiqtVirtualQState(QState* parent): QState(parent) {} + MiqtVirtualQState(QState::ChildMode childMode, QState* parent): QState(childMode, parent) {} + + virtual ~MiqtVirtualQState() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__onEntry = 0; + + // Subclass to allow providing a Go implementation + virtual void onEntry(QEvent* event) override { + if (handle__onEntry == 0) { + QState::onEntry(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QState_onEntry(this, handle__onEntry, sigval1); + + } + + friend void QState_virtualbase_onEntry(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__onExit = 0; + + // Subclass to allow providing a Go implementation + virtual void onExit(QEvent* event) override { + if (handle__onExit == 0) { + QState::onExit(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QState_onExit(this, handle__onExit, sigval1); + + } + + friend void QState_virtualbase_onExit(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* e) override { + if (handle__event == 0) { + return QState::event(e); + } + + QEvent* sigval1 = e; + bool callback_return_value = miqt_exec_callback_QState_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QState_virtualbase_event(void* self, QEvent* e); + + // 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 QState::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QState_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QState_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) { + QState::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QState_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QState_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) { + QState::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QState_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QState_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) { + QState::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QState_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QState_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) { + QState::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QState_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QState_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) { + QState::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QState_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QState_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QState_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QState_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QState_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QState_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QState* QState_new() { + return new (std::nothrow) MiqtVirtualQState(); +} + +QState* QState_new2(int childMode) { + return new (std::nothrow) MiqtVirtualQState(static_cast(childMode)); +} + +QState* QState_new3(QState* parent) { + return new (std::nothrow) MiqtVirtualQState(parent); +} + +QState* QState_new4(int childMode, QState* parent) { + return new (std::nothrow) MiqtVirtualQState(static_cast(childMode), parent); +} + +void QState_virtbase(QState* src, QAbstractState** outptr_QAbstractState) { + *outptr_QAbstractState = static_cast(src); +} + +QMetaObject* QState_metaObject(const QState* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QState_metacast(QState* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QState_tr(const char* s) { + QString _ret = QState::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; +} + +QAbstractState* QState_errorState(const QState* self) { + return self->errorState(); +} + +void QState_setErrorState(QState* self, QAbstractState* state) { + self->setErrorState(state); +} + +void QState_addTransition(QState* self, QAbstractTransition* transition) { + self->addTransition(transition); +} + +QSignalTransition* QState_addTransition2(QState* self, QObject* sender, const char* signal, QAbstractState* target) { + return self->addTransition(sender, signal, target); +} + +QAbstractTransition* QState_addTransitionWithTarget(QState* self, QAbstractState* target) { + return self->addTransition(target); +} + +void QState_removeTransition(QState* self, QAbstractTransition* transition) { + self->removeTransition(transition); +} + +struct miqt_array /* of QAbstractTransition* */ QState_transitions(const QState* self) { + QList _ret = self->transitions(); + // Convert QList<> from C++ memory to manually-managed C memory + QAbstractTransition** _arr = static_cast(malloc(sizeof(QAbstractTransition*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = _ret[i]; + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +QAbstractState* QState_initialState(const QState* self) { + return self->initialState(); +} + +void QState_setInitialState(QState* self, QAbstractState* state) { + self->setInitialState(state); +} + +int QState_childMode(const QState* self) { + QState::ChildMode _ret = self->childMode(); + return static_cast(_ret); +} + +void QState_setChildMode(QState* self, int mode) { + self->setChildMode(static_cast(mode)); +} + +void QState_assignProperty(QState* self, QObject* object, const char* name, QVariant* value) { + self->assignProperty(object, name, *value); +} + +struct miqt_string QState_tr2(const char* s, const char* c) { + QString _ret = QState::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 QState_tr3(const char* s, const char* c, int n) { + QString _ret = QState::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 QState_override_virtual_onEntry(void* self, intptr_t slot) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onEntry = slot; + return true; +} + +void QState_virtualbase_onEntry(void* self, QEvent* event) { + static_cast(self)->QState::onEntry(event); +} + +bool QState_override_virtual_onExit(void* self, intptr_t slot) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onExit = slot; + return true; +} + +void QState_virtualbase_onExit(void* self, QEvent* event) { + static_cast(self)->QState::onExit(event); +} + +bool QState_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QState_virtualbase_event(void* self, QEvent* e) { + return static_cast(self)->QState::event(e); +} + +bool QState_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QState_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QState::eventFilter(watched, event); +} + +bool QState_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QState_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QState::timerEvent(event); +} + +bool QState_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QState_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QState::childEvent(event); +} + +bool QState_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QState_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QState::customEvent(event); +} + +bool QState_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QState_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QState::connectNotify(*signal); +} + +bool QState_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QState_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QState::disconnectNotify(*signal); +} + +QObject* QState_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QState_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QState_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QState_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQState* self_cast = dynamic_cast( (QState*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QState_connect_finished(QState* self, intptr_t slot) { + QState::connect(self, &QState::finished, self, [=]() { + miqt_exec_callback_QState_finished(slot); + }); +} + +void QState_connect_propertiesAssigned(QState* self, intptr_t slot) { + QState::connect(self, &QState::propertiesAssigned, self, [=]() { + miqt_exec_callback_QState_propertiesAssigned(slot); + }); +} + +void QState_connect_childModeChanged(QState* self, intptr_t slot) { + QState::connect(self, &QState::childModeChanged, self, [=]() { + miqt_exec_callback_QState_childModeChanged(slot); + }); +} + +void QState_connect_initialStateChanged(QState* self, intptr_t slot) { + QState::connect(self, &QState::initialStateChanged, self, [=]() { + miqt_exec_callback_QState_initialStateChanged(slot); + }); +} + +void QState_connect_errorStateChanged(QState* self, intptr_t slot) { + QState::connect(self, &QState::errorStateChanged, self, [=]() { + miqt_exec_callback_QState_errorStateChanged(slot); + }); +} + +void QState_delete(QState* self) { + delete self; +} + diff --git a/qt6/statemachine/gen_qstate.go b/qt6/statemachine/gen_qstate.go new file mode 100644 index 000000000..fe5829616 --- /dev/null +++ b/qt6/statemachine/gen_qstate.go @@ -0,0 +1,570 @@ +package statemachine + +/* + +#include "gen_qstate.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QState__ChildMode int + +const ( + QState__ExclusiveStates QState__ChildMode = 0 + QState__ParallelStates QState__ChildMode = 1 +) + +type QState__RestorePolicy int + +const ( + QState__DontRestoreProperties QState__RestorePolicy = 0 + QState__RestoreProperties QState__RestorePolicy = 1 +) + +type QState struct { + h *C.QState + *QAbstractState +} + +func (this *QState) cPointer() *C.QState { + if this == nil { + return nil + } + return this.h +} + +func (this *QState) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQState constructs the type using only CGO pointers. +func newQState(h *C.QState) *QState { + if h == nil { + return nil + } + var outptr_QAbstractState *C.QAbstractState = nil + C.QState_virtbase(h, &outptr_QAbstractState) + + return &QState{h: h, + QAbstractState: newQAbstractState(outptr_QAbstractState)} +} + +// UnsafeNewQState constructs the type using only unsafe pointers. +func UnsafeNewQState(h unsafe.Pointer) *QState { + return newQState((*C.QState)(h)) +} + +// NewQState constructs a new QState object. +func NewQState() *QState { + + return newQState(C.QState_new()) +} + +// NewQState2 constructs a new QState object. +func NewQState2(childMode QState__ChildMode) *QState { + + return newQState(C.QState_new2((C.int)(childMode))) +} + +// NewQState3 constructs a new QState object. +func NewQState3(parent *QState) *QState { + + return newQState(C.QState_new3(parent.cPointer())) +} + +// NewQState4 constructs a new QState object. +func NewQState4(childMode QState__ChildMode, parent *QState) *QState { + + return newQState(C.QState_new4((C.int)(childMode), parent.cPointer())) +} + +func (this *QState) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QState_metaObject(this.h))) +} + +func (this *QState) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QState_metacast(this.h, param1_Cstring)) +} + +func QState_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QState_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QState) ErrorState() *QAbstractState { + return newQAbstractState(C.QState_errorState(this.h)) +} + +func (this *QState) SetErrorState(state *QAbstractState) { + C.QState_setErrorState(this.h, state.cPointer()) +} + +func (this *QState) AddTransition(transition *QAbstractTransition) { + C.QState_addTransition(this.h, transition.cPointer()) +} + +func (this *QState) AddTransition2(sender *qt6.QObject, signal string, target *QAbstractState) *QSignalTransition { + signal_Cstring := C.CString(signal) + defer C.free(unsafe.Pointer(signal_Cstring)) + return newQSignalTransition(C.QState_addTransition2(this.h, (*C.QObject)(sender.UnsafePointer()), signal_Cstring, target.cPointer())) +} + +func (this *QState) AddTransitionWithTarget(target *QAbstractState) *QAbstractTransition { + return newQAbstractTransition(C.QState_addTransitionWithTarget(this.h, target.cPointer())) +} + +func (this *QState) RemoveTransition(transition *QAbstractTransition) { + C.QState_removeTransition(this.h, transition.cPointer()) +} + +func (this *QState) Transitions() []*QAbstractTransition { + var _ma C.struct_miqt_array = C.QState_transitions(this.h) + _ret := make([]*QAbstractTransition, int(_ma.len)) + _outCast := (*[0xffff]*C.QAbstractTransition)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _ret[i] = newQAbstractTransition(_outCast[i]) + } + return _ret +} + +func (this *QState) InitialState() *QAbstractState { + return newQAbstractState(C.QState_initialState(this.h)) +} + +func (this *QState) SetInitialState(state *QAbstractState) { + C.QState_setInitialState(this.h, state.cPointer()) +} + +func (this *QState) ChildMode() QState__ChildMode { + return (QState__ChildMode)(C.QState_childMode(this.h)) +} + +func (this *QState) SetChildMode(mode QState__ChildMode) { + C.QState_setChildMode(this.h, (C.int)(mode)) +} + +func (this *QState) AssignProperty(object *qt6.QObject, name string, value *qt6.QVariant) { + name_Cstring := C.CString(name) + defer C.free(unsafe.Pointer(name_Cstring)) + C.QState_assignProperty(this.h, (*C.QObject)(object.UnsafePointer()), name_Cstring, (*C.QVariant)(value.UnsafePointer())) +} + +func QState_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.QState_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QState_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.QState_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 +} + +// Sender can only be called from a QState that was directly constructed. +func (this *QState) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QState_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 QState that was directly constructed. +func (this *QState) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QState_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 QState that was directly constructed. +func (this *QState) 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.QState_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 QState that was directly constructed. +func (this *QState) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QState_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 *QState) callVirtualBase_OnEntry(event *qt6.QEvent) { + + C.QState_virtualbase_onEntry(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QState) OnOnEntry(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QState_override_virtual_onEntry(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QState_onEntry +func miqt_exec_callback_QState_onEntry(self *C.QState, 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((&QState{h: self}).callVirtualBase_OnEntry, slotval1) + +} + +func (this *QState) callVirtualBase_OnExit(event *qt6.QEvent) { + + C.QState_virtualbase_onExit(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QState) OnOnExit(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QState_override_virtual_onExit(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QState_onExit +func miqt_exec_callback_QState_onExit(self *C.QState, 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((&QState{h: self}).callVirtualBase_OnExit, slotval1) + +} + +func (this *QState) callVirtualBase_Event(e *qt6.QEvent) bool { + + return (bool)(C.QState_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(e.UnsafePointer()))) + +} +func (this *QState) OnEvent(slot func(super func(e *qt6.QEvent) bool, e *qt6.QEvent) bool) { + ok := C.QState_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_QState_event +func miqt_exec_callback_QState_event(self *C.QState, cb C.intptr_t, e *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(e *qt6.QEvent) bool, e *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(e)) + + virtualReturn := gofunc((&QState{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QState) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QState_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QState) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QState_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_QState_eventFilter +func miqt_exec_callback_QState_eventFilter(self *C.QState, 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((&QState{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QState) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QState_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QState) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QState_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_QState_timerEvent +func miqt_exec_callback_QState_timerEvent(self *C.QState, 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((&QState{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QState) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QState_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QState) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QState_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_QState_childEvent +func miqt_exec_callback_QState_childEvent(self *C.QState, 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((&QState{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QState) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QState_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QState) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QState_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_QState_customEvent +func miqt_exec_callback_QState_customEvent(self *C.QState, 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((&QState{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QState) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QState_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QState) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QState_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_QState_connectNotify +func miqt_exec_callback_QState_connectNotify(self *C.QState, 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((&QState{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QState) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QState_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QState) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QState_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_QState_disconnectNotify +func miqt_exec_callback_QState_disconnectNotify(self *C.QState, 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((&QState{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} +func (this *QState) OnFinished(slot func()) { + C.QState_connect_finished(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QState_finished +func miqt_exec_callback_QState_finished(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 *QState) OnPropertiesAssigned(slot func()) { + C.QState_connect_propertiesAssigned(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QState_propertiesAssigned +func miqt_exec_callback_QState_propertiesAssigned(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 *QState) OnChildModeChanged(slot func()) { + C.QState_connect_childModeChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QState_childModeChanged +func miqt_exec_callback_QState_childModeChanged(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 *QState) OnInitialStateChanged(slot func()) { + C.QState_connect_initialStateChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QState_initialStateChanged +func miqt_exec_callback_QState_initialStateChanged(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 *QState) OnErrorStateChanged(slot func()) { + C.QState_connect_errorStateChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QState_errorStateChanged +func miqt_exec_callback_QState_errorStateChanged(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +// Delete this object from C++ memory. +func (this *QState) Delete() { + C.QState_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 *QState) GoGC() { + runtime.SetFinalizer(this, func(this *QState) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/statemachine/gen_qstate.h b/qt6/statemachine/gen_qstate.h new file mode 100644 index 000000000..3a6102753 --- /dev/null +++ b/qt6/statemachine/gen_qstate.h @@ -0,0 +1,105 @@ +#pragma once +#ifndef MIQT_QT6_STATEMACHINE_GEN_QSTATE_H +#define MIQT_QT6_STATEMACHINE_GEN_QSTATE_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractState; +class QAbstractTransition; +class QChildEvent; +class QEvent; +class QMetaMethod; +class QMetaObject; +class QObject; +class QSignalTransition; +class QState; +class QTimerEvent; +class QVariant; +#else +typedef struct QAbstractState QAbstractState; +typedef struct QAbstractTransition QAbstractTransition; +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QSignalTransition QSignalTransition; +typedef struct QState QState; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +#endif + +QState* QState_new(); +QState* QState_new2(int childMode); +QState* QState_new3(QState* parent); +QState* QState_new4(int childMode, QState* parent); +void QState_virtbase(QState* src, QAbstractState** outptr_QAbstractState); +QMetaObject* QState_metaObject(const QState* self); +void* QState_metacast(QState* self, const char* param1); +struct miqt_string QState_tr(const char* s); +QAbstractState* QState_errorState(const QState* self); +void QState_setErrorState(QState* self, QAbstractState* state); +void QState_addTransition(QState* self, QAbstractTransition* transition); +QSignalTransition* QState_addTransition2(QState* self, QObject* sender, const char* signal, QAbstractState* target); +QAbstractTransition* QState_addTransitionWithTarget(QState* self, QAbstractState* target); +void QState_removeTransition(QState* self, QAbstractTransition* transition); +struct miqt_array /* of QAbstractTransition* */ QState_transitions(const QState* self); +QAbstractState* QState_initialState(const QState* self); +void QState_setInitialState(QState* self, QAbstractState* state); +int QState_childMode(const QState* self); +void QState_setChildMode(QState* self, int mode); +void QState_assignProperty(QState* self, QObject* object, const char* name, QVariant* value); +void QState_onEntry(QState* self, QEvent* event); +void QState_onExit(QState* self, QEvent* event); +bool QState_event(QState* self, QEvent* e); +struct miqt_string QState_tr2(const char* s, const char* c); +struct miqt_string QState_tr3(const char* s, const char* c, int n); + +bool QState_override_virtual_onEntry(void* self, intptr_t slot); +void QState_virtualbase_onEntry(void* self, QEvent* event); +bool QState_override_virtual_onExit(void* self, intptr_t slot); +void QState_virtualbase_onExit(void* self, QEvent* event); +bool QState_override_virtual_event(void* self, intptr_t slot); +bool QState_virtualbase_event(void* self, QEvent* e); +bool QState_override_virtual_eventFilter(void* self, intptr_t slot); +bool QState_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QState_override_virtual_timerEvent(void* self, intptr_t slot); +void QState_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QState_override_virtual_childEvent(void* self, intptr_t slot); +void QState_virtualbase_childEvent(void* self, QChildEvent* event); +bool QState_override_virtual_customEvent(void* self, intptr_t slot); +void QState_virtualbase_customEvent(void* self, QEvent* event); +bool QState_override_virtual_connectNotify(void* self, intptr_t slot); +void QState_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QState_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QState_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QState_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QState_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QState_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QState_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QState_connect_finished(QState* self, intptr_t slot); +void QState_connect_propertiesAssigned(QState* self, intptr_t slot); +void QState_connect_childModeChanged(QState* self, intptr_t slot); +void QState_connect_initialStateChanged(QState* self, intptr_t slot); +void QState_connect_errorStateChanged(QState* self, intptr_t slot); + +void QState_delete(QState* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/statemachine/gen_qstatemachine.cpp b/qt6/statemachine/gen_qstatemachine.cpp new file mode 100644 index 000000000..23ca51dac --- /dev/null +++ b/qt6/statemachine/gen_qstatemachine.cpp @@ -0,0 +1,936 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define WORKAROUND_INNER_CLASS_DEFINITION_QStateMachine__SignalEvent +#define WORKAROUND_INNER_CLASS_DEFINITION_QStateMachine__WrappedEvent +#include +#include +#include +#include +#include +#include +#include "gen_qstatemachine.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QStateMachine_runningChanged(intptr_t, bool); +void miqt_exec_callback_QStateMachine_started(intptr_t); +void miqt_exec_callback_QStateMachine_stopped(intptr_t); +bool miqt_exec_callback_QStateMachine_eventFilter(QStateMachine*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QStateMachine_onEntry(QStateMachine*, intptr_t, QEvent*); +void miqt_exec_callback_QStateMachine_onExit(QStateMachine*, intptr_t, QEvent*); +void miqt_exec_callback_QStateMachine_beginSelectTransitions(QStateMachine*, intptr_t, QEvent*); +void miqt_exec_callback_QStateMachine_endSelectTransitions(QStateMachine*, intptr_t, QEvent*); +void miqt_exec_callback_QStateMachine_beginMicrostep(QStateMachine*, intptr_t, QEvent*); +void miqt_exec_callback_QStateMachine_endMicrostep(QStateMachine*, intptr_t, QEvent*); +bool miqt_exec_callback_QStateMachine_event(QStateMachine*, intptr_t, QEvent*); +void miqt_exec_callback_QStateMachine_timerEvent(QStateMachine*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QStateMachine_childEvent(QStateMachine*, intptr_t, QChildEvent*); +void miqt_exec_callback_QStateMachine_customEvent(QStateMachine*, intptr_t, QEvent*); +void miqt_exec_callback_QStateMachine_connectNotify(QStateMachine*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QStateMachine_disconnectNotify(QStateMachine*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QStateMachine__SignalEvent_setAccepted(QStateMachine__SignalEvent*, intptr_t, bool); +QEvent* miqt_exec_callback_QStateMachine__SignalEvent_clone(const QStateMachine__SignalEvent*, intptr_t); +void miqt_exec_callback_QStateMachine__WrappedEvent_setAccepted(QStateMachine__WrappedEvent*, intptr_t, bool); +QEvent* miqt_exec_callback_QStateMachine__WrappedEvent_clone(const QStateMachine__WrappedEvent*, intptr_t); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQStateMachine final : public QStateMachine { +public: + + MiqtVirtualQStateMachine(): QStateMachine() {} + MiqtVirtualQStateMachine(QState::ChildMode childMode): QStateMachine(childMode) {} + MiqtVirtualQStateMachine(QObject* parent): QStateMachine(parent) {} + MiqtVirtualQStateMachine(QState::ChildMode childMode, QObject* parent): QStateMachine(childMode, parent) {} + + virtual ~MiqtVirtualQStateMachine() override = default; + + // 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 QStateMachine::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QStateMachine_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QStateMachine_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__onEntry = 0; + + // Subclass to allow providing a Go implementation + virtual void onEntry(QEvent* event) override { + if (handle__onEntry == 0) { + QStateMachine::onEntry(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QStateMachine_onEntry(this, handle__onEntry, sigval1); + + } + + friend void QStateMachine_virtualbase_onEntry(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__onExit = 0; + + // Subclass to allow providing a Go implementation + virtual void onExit(QEvent* event) override { + if (handle__onExit == 0) { + QStateMachine::onExit(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QStateMachine_onExit(this, handle__onExit, sigval1); + + } + + friend void QStateMachine_virtualbase_onExit(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__beginSelectTransitions = 0; + + // Subclass to allow providing a Go implementation + virtual void beginSelectTransitions(QEvent* event) override { + if (handle__beginSelectTransitions == 0) { + QStateMachine::beginSelectTransitions(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QStateMachine_beginSelectTransitions(this, handle__beginSelectTransitions, sigval1); + + } + + friend void QStateMachine_virtualbase_beginSelectTransitions(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__endSelectTransitions = 0; + + // Subclass to allow providing a Go implementation + virtual void endSelectTransitions(QEvent* event) override { + if (handle__endSelectTransitions == 0) { + QStateMachine::endSelectTransitions(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QStateMachine_endSelectTransitions(this, handle__endSelectTransitions, sigval1); + + } + + friend void QStateMachine_virtualbase_endSelectTransitions(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__beginMicrostep = 0; + + // Subclass to allow providing a Go implementation + virtual void beginMicrostep(QEvent* event) override { + if (handle__beginMicrostep == 0) { + QStateMachine::beginMicrostep(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QStateMachine_beginMicrostep(this, handle__beginMicrostep, sigval1); + + } + + friend void QStateMachine_virtualbase_beginMicrostep(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__endMicrostep = 0; + + // Subclass to allow providing a Go implementation + virtual void endMicrostep(QEvent* event) override { + if (handle__endMicrostep == 0) { + QStateMachine::endMicrostep(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QStateMachine_endMicrostep(this, handle__endMicrostep, sigval1); + + } + + friend void QStateMachine_virtualbase_endMicrostep(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* e) override { + if (handle__event == 0) { + return QStateMachine::event(e); + } + + QEvent* sigval1 = e; + bool callback_return_value = miqt_exec_callback_QStateMachine_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QStateMachine_virtualbase_event(void* self, QEvent* e); + + // 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) { + QStateMachine::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QStateMachine_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QStateMachine_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) { + QStateMachine::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QStateMachine_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QStateMachine_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) { + QStateMachine::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QStateMachine_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QStateMachine_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) { + QStateMachine::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QStateMachine_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QStateMachine_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) { + QStateMachine::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QStateMachine_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QStateMachine_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QStateMachine_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QStateMachine_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QStateMachine_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QStateMachine_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QStateMachine* QStateMachine_new() { + return new (std::nothrow) MiqtVirtualQStateMachine(); +} + +QStateMachine* QStateMachine_new2(int childMode) { + return new (std::nothrow) MiqtVirtualQStateMachine(static_cast(childMode)); +} + +QStateMachine* QStateMachine_new3(QObject* parent) { + return new (std::nothrow) MiqtVirtualQStateMachine(parent); +} + +QStateMachine* QStateMachine_new4(int childMode, QObject* parent) { + return new (std::nothrow) MiqtVirtualQStateMachine(static_cast(childMode), parent); +} + +void QStateMachine_virtbase(QStateMachine* src, QState** outptr_QState) { + *outptr_QState = static_cast(src); +} + +QMetaObject* QStateMachine_metaObject(const QStateMachine* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QStateMachine_metacast(QStateMachine* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QStateMachine_tr(const char* s) { + QString _ret = QStateMachine::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 QStateMachine_addState(QStateMachine* self, QAbstractState* state) { + self->addState(state); +} + +void QStateMachine_removeState(QStateMachine* self, QAbstractState* state) { + self->removeState(state); +} + +int QStateMachine_error(const QStateMachine* self) { + QStateMachine::Error _ret = self->error(); + return static_cast(_ret); +} + +struct miqt_string QStateMachine_errorString(const QStateMachine* self) { + QString _ret = self->errorString(); + // 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 QStateMachine_clearError(QStateMachine* self) { + self->clearError(); +} + +bool QStateMachine_isRunning(const QStateMachine* self) { + return self->isRunning(); +} + +bool QStateMachine_isAnimated(const QStateMachine* self) { + return self->isAnimated(); +} + +void QStateMachine_setAnimated(QStateMachine* self, bool enabled) { + self->setAnimated(enabled); +} + +void QStateMachine_addDefaultAnimation(QStateMachine* self, QAbstractAnimation* animation) { + self->addDefaultAnimation(animation); +} + +struct miqt_array /* of QAbstractAnimation* */ QStateMachine_defaultAnimations(const QStateMachine* self) { + QList _ret = self->defaultAnimations(); + // Convert QList<> from C++ memory to manually-managed C memory + QAbstractAnimation** _arr = static_cast(malloc(sizeof(QAbstractAnimation*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = _ret[i]; + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +void QStateMachine_removeDefaultAnimation(QStateMachine* self, QAbstractAnimation* animation) { + self->removeDefaultAnimation(animation); +} + +int QStateMachine_globalRestorePolicy(const QStateMachine* self) { + QState::RestorePolicy _ret = self->globalRestorePolicy(); + return static_cast(_ret); +} + +void QStateMachine_setGlobalRestorePolicy(QStateMachine* self, int restorePolicy) { + self->setGlobalRestorePolicy(static_cast(restorePolicy)); +} + +void QStateMachine_postEvent(QStateMachine* self, QEvent* event) { + self->postEvent(event); +} + +int QStateMachine_postDelayedEvent(QStateMachine* self, QEvent* event, int delay) { + return self->postDelayedEvent(event, static_cast(delay)); +} + +bool QStateMachine_cancelDelayedEvent(QStateMachine* self, int id) { + return self->cancelDelayedEvent(static_cast(id)); +} + +struct miqt_array /* set of QAbstractState* */ QStateMachine_configuration(const QStateMachine* self) { + QSet _ret = self->configuration(); + // Convert QSet<> from C++ memory to manually-managed C memory + QAbstractState** _arr = static_cast(malloc(sizeof(QAbstractState*) * _ret.size())); + int _ctr = 0; + QSetIterator _itr(_ret); + while (_itr.hasNext()) { + _arr[_ctr++] = _itr.next(); + } + struct miqt_array _out; + _out.len = _ret.size(); + _out.data = static_cast(_arr); + return _out; +} + +bool QStateMachine_eventFilter(QStateMachine* self, QObject* watched, QEvent* event) { + return self->eventFilter(watched, event); +} + +void QStateMachine_start(QStateMachine* self) { + self->start(); +} + +void QStateMachine_stop(QStateMachine* self) { + self->stop(); +} + +void QStateMachine_setRunning(QStateMachine* self, bool running) { + self->setRunning(running); +} + +void QStateMachine_runningChanged(QStateMachine* self, bool running) { + self->runningChanged(running); +} + +void QStateMachine_connect_runningChanged(QStateMachine* self, intptr_t slot) { + QStateMachine::connect(self, static_cast(&QStateMachine::runningChanged), self, [=](bool running) { + bool sigval1 = running; + miqt_exec_callback_QStateMachine_runningChanged(slot, sigval1); + }); +} + +struct miqt_string QStateMachine_tr2(const char* s, const char* c) { + QString _ret = QStateMachine::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 QStateMachine_tr3(const char* s, const char* c, int n) { + QString _ret = QStateMachine::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 QStateMachine_postEvent2(QStateMachine* self, QEvent* event, int priority) { + self->postEvent(event, static_cast(priority)); +} + +bool QStateMachine_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QStateMachine_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QStateMachine::eventFilter(watched, event); +} + +bool QStateMachine_override_virtual_onEntry(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onEntry = slot; + return true; +} + +void QStateMachine_virtualbase_onEntry(void* self, QEvent* event) { + static_cast(self)->QStateMachine::onEntry(event); +} + +bool QStateMachine_override_virtual_onExit(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__onExit = slot; + return true; +} + +void QStateMachine_virtualbase_onExit(void* self, QEvent* event) { + static_cast(self)->QStateMachine::onExit(event); +} + +bool QStateMachine_override_virtual_beginSelectTransitions(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__beginSelectTransitions = slot; + return true; +} + +void QStateMachine_virtualbase_beginSelectTransitions(void* self, QEvent* event) { + static_cast(self)->QStateMachine::beginSelectTransitions(event); +} + +bool QStateMachine_override_virtual_endSelectTransitions(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__endSelectTransitions = slot; + return true; +} + +void QStateMachine_virtualbase_endSelectTransitions(void* self, QEvent* event) { + static_cast(self)->QStateMachine::endSelectTransitions(event); +} + +bool QStateMachine_override_virtual_beginMicrostep(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__beginMicrostep = slot; + return true; +} + +void QStateMachine_virtualbase_beginMicrostep(void* self, QEvent* event) { + static_cast(self)->QStateMachine::beginMicrostep(event); +} + +bool QStateMachine_override_virtual_endMicrostep(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__endMicrostep = slot; + return true; +} + +void QStateMachine_virtualbase_endMicrostep(void* self, QEvent* event) { + static_cast(self)->QStateMachine::endMicrostep(event); +} + +bool QStateMachine_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QStateMachine_virtualbase_event(void* self, QEvent* e) { + return static_cast(self)->QStateMachine::event(e); +} + +bool QStateMachine_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QStateMachine_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QStateMachine::timerEvent(event); +} + +bool QStateMachine_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QStateMachine_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QStateMachine::childEvent(event); +} + +bool QStateMachine_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QStateMachine_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QStateMachine::customEvent(event); +} + +bool QStateMachine_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QStateMachine_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QStateMachine::connectNotify(*signal); +} + +bool QStateMachine_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QStateMachine_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QStateMachine::disconnectNotify(*signal); +} + +QObject* QStateMachine_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QStateMachine_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QStateMachine_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QStateMachine_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQStateMachine* self_cast = dynamic_cast( (QStateMachine*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QStateMachine_connect_started(QStateMachine* self, intptr_t slot) { + QStateMachine::connect(self, &QStateMachine::started, self, [=]() { + miqt_exec_callback_QStateMachine_started(slot); + }); +} + +void QStateMachine_connect_stopped(QStateMachine* self, intptr_t slot) { + QStateMachine::connect(self, &QStateMachine::stopped, self, [=]() { + miqt_exec_callback_QStateMachine_stopped(slot); + }); +} + +void QStateMachine_delete(QStateMachine* self) { + delete self; +} + +class MiqtVirtualQStateMachineSignalEvent final : public QStateMachine::SignalEvent { +public: + + MiqtVirtualQStateMachineSignalEvent(QObject* sender, int signalIndex, const QList& arguments): QStateMachine::SignalEvent(sender, signalIndex, arguments) {} + MiqtVirtualQStateMachineSignalEvent(const QStateMachine::SignalEvent& param1): QStateMachine::SignalEvent(param1) {} + + virtual ~MiqtVirtualQStateMachineSignalEvent() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__setAccepted = 0; + + // Subclass to allow providing a Go implementation + virtual void setAccepted(bool accepted) override { + if (handle__setAccepted == 0) { + QStateMachine::SignalEvent::setAccepted(accepted); + return; + } + + bool sigval1 = accepted; + miqt_exec_callback_QStateMachine__SignalEvent_setAccepted(this, handle__setAccepted, sigval1); + + } + + friend void QStateMachine__SignalEvent_virtualbase_setAccepted(void* self, bool accepted); + + // cgo.Handle value for overwritten implementation + intptr_t handle__clone = 0; + + // Subclass to allow providing a Go implementation + virtual QEvent* clone() const override { + if (handle__clone == 0) { + return QStateMachine::SignalEvent::clone(); + } + + QEvent* callback_return_value = miqt_exec_callback_QStateMachine__SignalEvent_clone(this, handle__clone); + return callback_return_value; + } + + friend QEvent* QStateMachine__SignalEvent_virtualbase_clone(const void* self); + +}; + +QStateMachine__SignalEvent* QStateMachine__SignalEvent_new(QObject* sender, int signalIndex, struct miqt_array /* of QVariant* */ arguments) { + QList arguments_QList; + arguments_QList.reserve(arguments.len); + QVariant** arguments_arr = static_cast(arguments.data); + for(size_t i = 0; i < arguments.len; ++i) { + arguments_QList.push_back(*(arguments_arr[i])); + } + return new (std::nothrow) MiqtVirtualQStateMachineSignalEvent(sender, static_cast(signalIndex), arguments_QList); +} + +QStateMachine__SignalEvent* QStateMachine__SignalEvent_new2(QStateMachine__SignalEvent* param1) { + return new (std::nothrow) MiqtVirtualQStateMachineSignalEvent(*param1); +} + +void QStateMachine__SignalEvent_virtbase(QStateMachine__SignalEvent* src, QEvent** outptr_QEvent) { + *outptr_QEvent = static_cast(src); +} + +QObject* QStateMachine__SignalEvent_sender(const QStateMachine__SignalEvent* self) { + return self->sender(); +} + +int QStateMachine__SignalEvent_signalIndex(const QStateMachine__SignalEvent* self) { + return self->signalIndex(); +} + +struct miqt_array /* of QVariant* */ QStateMachine__SignalEvent_arguments(const QStateMachine__SignalEvent* self) { + QList _ret = self->arguments(); + // Convert QList<> from C++ memory to manually-managed C memory + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QVariant(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +void QStateMachine__SignalEvent_operatorAssign(QStateMachine__SignalEvent* self, QStateMachine__SignalEvent* param1) { + self->operator=(*param1); +} + +bool QStateMachine__SignalEvent_override_virtual_setAccepted(void* self, intptr_t slot) { + MiqtVirtualQStateMachineSignalEvent* self_cast = dynamic_cast( (QStateMachine::SignalEvent*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setAccepted = slot; + return true; +} + +void QStateMachine__SignalEvent_virtualbase_setAccepted(void* self, bool accepted) { + static_cast(self)->QStateMachine::SignalEvent::setAccepted(accepted); +} + +bool QStateMachine__SignalEvent_override_virtual_clone(void* self, intptr_t slot) { + MiqtVirtualQStateMachineSignalEvent* self_cast = dynamic_cast( (QStateMachine::SignalEvent*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__clone = slot; + return true; +} + +QEvent* QStateMachine__SignalEvent_virtualbase_clone(const void* self) { + return static_cast(self)->QStateMachine::SignalEvent::clone(); +} + +void QStateMachine__SignalEvent_delete(QStateMachine__SignalEvent* self) { + delete self; +} + +class MiqtVirtualQStateMachineWrappedEvent final : public QStateMachine::WrappedEvent { +public: + + MiqtVirtualQStateMachineWrappedEvent(QObject* object, QEvent* event): QStateMachine::WrappedEvent(object, event) {} + MiqtVirtualQStateMachineWrappedEvent(const QStateMachine::WrappedEvent& param1): QStateMachine::WrappedEvent(param1) {} + + virtual ~MiqtVirtualQStateMachineWrappedEvent() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__setAccepted = 0; + + // Subclass to allow providing a Go implementation + virtual void setAccepted(bool accepted) override { + if (handle__setAccepted == 0) { + QStateMachine::WrappedEvent::setAccepted(accepted); + return; + } + + bool sigval1 = accepted; + miqt_exec_callback_QStateMachine__WrappedEvent_setAccepted(this, handle__setAccepted, sigval1); + + } + + friend void QStateMachine__WrappedEvent_virtualbase_setAccepted(void* self, bool accepted); + + // cgo.Handle value for overwritten implementation + intptr_t handle__clone = 0; + + // Subclass to allow providing a Go implementation + virtual QEvent* clone() const override { + if (handle__clone == 0) { + return QStateMachine::WrappedEvent::clone(); + } + + QEvent* callback_return_value = miqt_exec_callback_QStateMachine__WrappedEvent_clone(this, handle__clone); + return callback_return_value; + } + + friend QEvent* QStateMachine__WrappedEvent_virtualbase_clone(const void* self); + +}; + +QStateMachine__WrappedEvent* QStateMachine__WrappedEvent_new(QObject* object, QEvent* event) { + return new (std::nothrow) MiqtVirtualQStateMachineWrappedEvent(object, event); +} + +QStateMachine__WrappedEvent* QStateMachine__WrappedEvent_new2(QStateMachine__WrappedEvent* param1) { + return new (std::nothrow) MiqtVirtualQStateMachineWrappedEvent(*param1); +} + +void QStateMachine__WrappedEvent_virtbase(QStateMachine__WrappedEvent* src, QEvent** outptr_QEvent) { + *outptr_QEvent = static_cast(src); +} + +QObject* QStateMachine__WrappedEvent_object(const QStateMachine__WrappedEvent* self) { + return self->object(); +} + +QEvent* QStateMachine__WrappedEvent_event(const QStateMachine__WrappedEvent* self) { + return self->event(); +} + +void QStateMachine__WrappedEvent_operatorAssign(QStateMachine__WrappedEvent* self, QStateMachine__WrappedEvent* param1) { + self->operator=(*param1); +} + +bool QStateMachine__WrappedEvent_override_virtual_setAccepted(void* self, intptr_t slot) { + MiqtVirtualQStateMachineWrappedEvent* self_cast = dynamic_cast( (QStateMachine::WrappedEvent*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__setAccepted = slot; + return true; +} + +void QStateMachine__WrappedEvent_virtualbase_setAccepted(void* self, bool accepted) { + static_cast(self)->QStateMachine::WrappedEvent::setAccepted(accepted); +} + +bool QStateMachine__WrappedEvent_override_virtual_clone(void* self, intptr_t slot) { + MiqtVirtualQStateMachineWrappedEvent* self_cast = dynamic_cast( (QStateMachine::WrappedEvent*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__clone = slot; + return true; +} + +QEvent* QStateMachine__WrappedEvent_virtualbase_clone(const void* self) { + return static_cast(self)->QStateMachine::WrappedEvent::clone(); +} + +void QStateMachine__WrappedEvent_delete(QStateMachine__WrappedEvent* self) { + delete self; +} + diff --git a/qt6/statemachine/gen_qstatemachine.go b/qt6/statemachine/gen_qstatemachine.go new file mode 100644 index 000000000..d10325213 --- /dev/null +++ b/qt6/statemachine/gen_qstatemachine.go @@ -0,0 +1,970 @@ +package statemachine + +/* + +#include "gen_qstatemachine.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QStateMachine__EventPriority int + +const ( + QStateMachine__NormalPriority QStateMachine__EventPriority = 0 + QStateMachine__HighPriority QStateMachine__EventPriority = 1 +) + +type QStateMachine__Error int + +const ( + QStateMachine__NoError QStateMachine__Error = 0 + QStateMachine__NoInitialStateError QStateMachine__Error = 1 + QStateMachine__NoDefaultStateInHistoryStateError QStateMachine__Error = 2 + QStateMachine__NoCommonAncestorForTransitionError QStateMachine__Error = 3 + QStateMachine__StateMachineChildModeSetToParallelError QStateMachine__Error = 4 +) + +type QStateMachine struct { + h *C.QStateMachine + *QState +} + +func (this *QStateMachine) cPointer() *C.QStateMachine { + if this == nil { + return nil + } + return this.h +} + +func (this *QStateMachine) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQStateMachine constructs the type using only CGO pointers. +func newQStateMachine(h *C.QStateMachine) *QStateMachine { + if h == nil { + return nil + } + var outptr_QState *C.QState = nil + C.QStateMachine_virtbase(h, &outptr_QState) + + return &QStateMachine{h: h, + QState: newQState(outptr_QState)} +} + +// UnsafeNewQStateMachine constructs the type using only unsafe pointers. +func UnsafeNewQStateMachine(h unsafe.Pointer) *QStateMachine { + return newQStateMachine((*C.QStateMachine)(h)) +} + +// NewQStateMachine constructs a new QStateMachine object. +func NewQStateMachine() *QStateMachine { + + return newQStateMachine(C.QStateMachine_new()) +} + +// NewQStateMachine2 constructs a new QStateMachine object. +func NewQStateMachine2(childMode QState__ChildMode) *QStateMachine { + + return newQStateMachine(C.QStateMachine_new2((C.int)(childMode))) +} + +// NewQStateMachine3 constructs a new QStateMachine object. +func NewQStateMachine3(parent *qt6.QObject) *QStateMachine { + + return newQStateMachine(C.QStateMachine_new3((*C.QObject)(parent.UnsafePointer()))) +} + +// NewQStateMachine4 constructs a new QStateMachine object. +func NewQStateMachine4(childMode QState__ChildMode, parent *qt6.QObject) *QStateMachine { + + return newQStateMachine(C.QStateMachine_new4((C.int)(childMode), (*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QStateMachine) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QStateMachine_metaObject(this.h))) +} + +func (this *QStateMachine) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QStateMachine_metacast(this.h, param1_Cstring)) +} + +func QStateMachine_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QStateMachine_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QStateMachine) AddState(state *QAbstractState) { + C.QStateMachine_addState(this.h, state.cPointer()) +} + +func (this *QStateMachine) RemoveState(state *QAbstractState) { + C.QStateMachine_removeState(this.h, state.cPointer()) +} + +func (this *QStateMachine) Error() QStateMachine__Error { + return (QStateMachine__Error)(C.QStateMachine_error(this.h)) +} + +func (this *QStateMachine) ErrorString() string { + var _ms C.struct_miqt_string = C.QStateMachine_errorString(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QStateMachine) ClearError() { + C.QStateMachine_clearError(this.h) +} + +func (this *QStateMachine) IsRunning() bool { + return (bool)(C.QStateMachine_isRunning(this.h)) +} + +func (this *QStateMachine) IsAnimated() bool { + return (bool)(C.QStateMachine_isAnimated(this.h)) +} + +func (this *QStateMachine) SetAnimated(enabled bool) { + C.QStateMachine_setAnimated(this.h, (C.bool)(enabled)) +} + +func (this *QStateMachine) AddDefaultAnimation(animation *qt6.QAbstractAnimation) { + C.QStateMachine_addDefaultAnimation(this.h, (*C.QAbstractAnimation)(animation.UnsafePointer())) +} + +func (this *QStateMachine) DefaultAnimations() []*qt6.QAbstractAnimation { + var _ma C.struct_miqt_array = C.QStateMachine_defaultAnimations(this.h) + _ret := make([]*qt6.QAbstractAnimation, int(_ma.len)) + _outCast := (*[0xffff]*C.QAbstractAnimation)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _ret[i] = qt6.UnsafeNewQAbstractAnimation(unsafe.Pointer(_outCast[i])) + } + return _ret +} + +func (this *QStateMachine) RemoveDefaultAnimation(animation *qt6.QAbstractAnimation) { + C.QStateMachine_removeDefaultAnimation(this.h, (*C.QAbstractAnimation)(animation.UnsafePointer())) +} + +func (this *QStateMachine) GlobalRestorePolicy() QState__RestorePolicy { + return (QState__RestorePolicy)(C.QStateMachine_globalRestorePolicy(this.h)) +} + +func (this *QStateMachine) SetGlobalRestorePolicy(restorePolicy QState__RestorePolicy) { + C.QStateMachine_setGlobalRestorePolicy(this.h, (C.int)(restorePolicy)) +} + +func (this *QStateMachine) PostEvent(event *qt6.QEvent) { + C.QStateMachine_postEvent(this.h, (*C.QEvent)(event.UnsafePointer())) +} + +func (this *QStateMachine) PostDelayedEvent(event *qt6.QEvent, delay int) int { + return (int)(C.QStateMachine_postDelayedEvent(this.h, (*C.QEvent)(event.UnsafePointer()), (C.int)(delay))) +} + +func (this *QStateMachine) CancelDelayedEvent(id int) bool { + return (bool)(C.QStateMachine_cancelDelayedEvent(this.h, (C.int)(id))) +} + +func (this *QStateMachine) Configuration() map[*QAbstractState]struct{} { + var _ma C.struct_miqt_array = C.QStateMachine_configuration(this.h) + _ret := make(map[*QAbstractState]struct{}, int(_ma.len)) + _outCast := (*[0xffff]*C.QAbstractState)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _element := newQAbstractState(_outCast[i]) + + _ret[_element] = struct{}{} + } + return _ret +} + +func (this *QStateMachine) EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + return (bool)(C.QStateMachine_eventFilter(this.h, (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) +} + +func (this *QStateMachine) Start() { + C.QStateMachine_start(this.h) +} + +func (this *QStateMachine) Stop() { + C.QStateMachine_stop(this.h) +} + +func (this *QStateMachine) SetRunning(running bool) { + C.QStateMachine_setRunning(this.h, (C.bool)(running)) +} + +func (this *QStateMachine) RunningChanged(running bool) { + C.QStateMachine_runningChanged(this.h, (C.bool)(running)) +} +func (this *QStateMachine) OnRunningChanged(slot func(running bool)) { + C.QStateMachine_connect_runningChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QStateMachine_runningChanged +func miqt_exec_callback_QStateMachine_runningChanged(cb C.intptr_t, running C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(running bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(running) + + gofunc(slotval1) +} + +func QStateMachine_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.QStateMachine_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QStateMachine_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.QStateMachine_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 *QStateMachine) PostEvent2(event *qt6.QEvent, priority QStateMachine__EventPriority) { + C.QStateMachine_postEvent2(this.h, (*C.QEvent)(event.UnsafePointer()), (C.int)(priority)) +} + +// Sender can only be called from a QStateMachine that was directly constructed. +func (this *QStateMachine) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QStateMachine_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 QStateMachine that was directly constructed. +func (this *QStateMachine) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QStateMachine_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 QStateMachine that was directly constructed. +func (this *QStateMachine) 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.QStateMachine_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 QStateMachine that was directly constructed. +func (this *QStateMachine) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QStateMachine_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 *QStateMachine) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QStateMachine_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QStateMachine) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QStateMachine_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_QStateMachine_eventFilter +func miqt_exec_callback_QStateMachine_eventFilter(self *C.QStateMachine, 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((&QStateMachine{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QStateMachine) callVirtualBase_OnEntry(event *qt6.QEvent) { + + C.QStateMachine_virtualbase_onEntry(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QStateMachine) OnOnEntry(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QStateMachine_override_virtual_onEntry(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QStateMachine_onEntry +func miqt_exec_callback_QStateMachine_onEntry(self *C.QStateMachine, 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((&QStateMachine{h: self}).callVirtualBase_OnEntry, slotval1) + +} + +func (this *QStateMachine) callVirtualBase_OnExit(event *qt6.QEvent) { + + C.QStateMachine_virtualbase_onExit(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QStateMachine) OnOnExit(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QStateMachine_override_virtual_onExit(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QStateMachine_onExit +func miqt_exec_callback_QStateMachine_onExit(self *C.QStateMachine, 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((&QStateMachine{h: self}).callVirtualBase_OnExit, slotval1) + +} + +func (this *QStateMachine) callVirtualBase_BeginSelectTransitions(event *qt6.QEvent) { + + C.QStateMachine_virtualbase_beginSelectTransitions(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QStateMachine) OnBeginSelectTransitions(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QStateMachine_override_virtual_beginSelectTransitions(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QStateMachine_beginSelectTransitions +func miqt_exec_callback_QStateMachine_beginSelectTransitions(self *C.QStateMachine, 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((&QStateMachine{h: self}).callVirtualBase_BeginSelectTransitions, slotval1) + +} + +func (this *QStateMachine) callVirtualBase_EndSelectTransitions(event *qt6.QEvent) { + + C.QStateMachine_virtualbase_endSelectTransitions(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QStateMachine) OnEndSelectTransitions(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QStateMachine_override_virtual_endSelectTransitions(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QStateMachine_endSelectTransitions +func miqt_exec_callback_QStateMachine_endSelectTransitions(self *C.QStateMachine, 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((&QStateMachine{h: self}).callVirtualBase_EndSelectTransitions, slotval1) + +} + +func (this *QStateMachine) callVirtualBase_BeginMicrostep(event *qt6.QEvent) { + + C.QStateMachine_virtualbase_beginMicrostep(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QStateMachine) OnBeginMicrostep(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QStateMachine_override_virtual_beginMicrostep(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QStateMachine_beginMicrostep +func miqt_exec_callback_QStateMachine_beginMicrostep(self *C.QStateMachine, 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((&QStateMachine{h: self}).callVirtualBase_BeginMicrostep, slotval1) + +} + +func (this *QStateMachine) callVirtualBase_EndMicrostep(event *qt6.QEvent) { + + C.QStateMachine_virtualbase_endMicrostep(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QStateMachine) OnEndMicrostep(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QStateMachine_override_virtual_endMicrostep(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QStateMachine_endMicrostep +func miqt_exec_callback_QStateMachine_endMicrostep(self *C.QStateMachine, 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((&QStateMachine{h: self}).callVirtualBase_EndMicrostep, slotval1) + +} + +func (this *QStateMachine) callVirtualBase_Event(e *qt6.QEvent) bool { + + return (bool)(C.QStateMachine_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(e.UnsafePointer()))) + +} +func (this *QStateMachine) OnEvent(slot func(super func(e *qt6.QEvent) bool, e *qt6.QEvent) bool) { + ok := C.QStateMachine_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_QStateMachine_event +func miqt_exec_callback_QStateMachine_event(self *C.QStateMachine, cb C.intptr_t, e *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(e *qt6.QEvent) bool, e *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(e)) + + virtualReturn := gofunc((&QStateMachine{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QStateMachine) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QStateMachine_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QStateMachine) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QStateMachine_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_QStateMachine_timerEvent +func miqt_exec_callback_QStateMachine_timerEvent(self *C.QStateMachine, 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((&QStateMachine{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QStateMachine) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QStateMachine_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QStateMachine) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QStateMachine_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_QStateMachine_childEvent +func miqt_exec_callback_QStateMachine_childEvent(self *C.QStateMachine, 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((&QStateMachine{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QStateMachine) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QStateMachine_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QStateMachine) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QStateMachine_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_QStateMachine_customEvent +func miqt_exec_callback_QStateMachine_customEvent(self *C.QStateMachine, 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((&QStateMachine{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QStateMachine) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QStateMachine_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QStateMachine) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QStateMachine_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_QStateMachine_connectNotify +func miqt_exec_callback_QStateMachine_connectNotify(self *C.QStateMachine, 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((&QStateMachine{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QStateMachine) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QStateMachine_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QStateMachine) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QStateMachine_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_QStateMachine_disconnectNotify +func miqt_exec_callback_QStateMachine_disconnectNotify(self *C.QStateMachine, 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((&QStateMachine{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} +func (this *QStateMachine) OnStarted(slot func()) { + C.QStateMachine_connect_started(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QStateMachine_started +func miqt_exec_callback_QStateMachine_started(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 *QStateMachine) OnStopped(slot func()) { + C.QStateMachine_connect_stopped(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QStateMachine_stopped +func miqt_exec_callback_QStateMachine_stopped(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +// Delete this object from C++ memory. +func (this *QStateMachine) Delete() { + C.QStateMachine_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 *QStateMachine) GoGC() { + runtime.SetFinalizer(this, func(this *QStateMachine) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type QStateMachine__SignalEvent struct { + h *C.QStateMachine__SignalEvent + *qt6.QEvent +} + +func (this *QStateMachine__SignalEvent) cPointer() *C.QStateMachine__SignalEvent { + if this == nil { + return nil + } + return this.h +} + +func (this *QStateMachine__SignalEvent) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQStateMachine__SignalEvent constructs the type using only CGO pointers. +func newQStateMachine__SignalEvent(h *C.QStateMachine__SignalEvent) *QStateMachine__SignalEvent { + if h == nil { + return nil + } + var outptr_QEvent *C.QEvent = nil + C.QStateMachine__SignalEvent_virtbase(h, &outptr_QEvent) + + return &QStateMachine__SignalEvent{h: h, + QEvent: qt6.UnsafeNewQEvent(unsafe.Pointer(outptr_QEvent))} +} + +// UnsafeNewQStateMachine__SignalEvent constructs the type using only unsafe pointers. +func UnsafeNewQStateMachine__SignalEvent(h unsafe.Pointer) *QStateMachine__SignalEvent { + return newQStateMachine__SignalEvent((*C.QStateMachine__SignalEvent)(h)) +} + +// NewQStateMachine__SignalEvent constructs a new QStateMachine::SignalEvent object. +func NewQStateMachine__SignalEvent(sender *qt6.QObject, signalIndex int, arguments []qt6.QVariant) *QStateMachine__SignalEvent { + arguments_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(arguments)))) + defer C.free(unsafe.Pointer(arguments_CArray)) + for i := range arguments { + arguments_CArray[i] = (*C.QVariant)(arguments[i].UnsafePointer()) + } + arguments_ma := C.struct_miqt_array{len: C.size_t(len(arguments)), data: unsafe.Pointer(arguments_CArray)} + + return newQStateMachine__SignalEvent(C.QStateMachine__SignalEvent_new((*C.QObject)(sender.UnsafePointer()), (C.int)(signalIndex), arguments_ma)) +} + +// NewQStateMachine__SignalEvent2 constructs a new QStateMachine::SignalEvent object. +func NewQStateMachine__SignalEvent2(param1 *QStateMachine__SignalEvent) *QStateMachine__SignalEvent { + + return newQStateMachine__SignalEvent(C.QStateMachine__SignalEvent_new2(param1.cPointer())) +} + +func (this *QStateMachine__SignalEvent) Sender() *qt6.QObject { + return qt6.UnsafeNewQObject(unsafe.Pointer(C.QStateMachine__SignalEvent_sender(this.h))) +} + +func (this *QStateMachine__SignalEvent) SignalIndex() int { + return (int)(C.QStateMachine__SignalEvent_signalIndex(this.h)) +} + +func (this *QStateMachine__SignalEvent) Arguments() []qt6.QVariant { + var _ma C.struct_miqt_array = C.QStateMachine__SignalEvent_arguments(this.h) + _ret := make([]qt6.QVariant, int(_ma.len)) + _outCast := (*[0xffff]*C.QVariant)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt6.UnsafeNewQVariant(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 *QStateMachine__SignalEvent) OperatorAssign(param1 *QStateMachine__SignalEvent) { + C.QStateMachine__SignalEvent_operatorAssign(this.h, param1.cPointer()) +} + +func (this *QStateMachine__SignalEvent) callVirtualBase_SetAccepted(accepted bool) { + + C.QStateMachine__SignalEvent_virtualbase_setAccepted(unsafe.Pointer(this.h), (C.bool)(accepted)) + +} +func (this *QStateMachine__SignalEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) { + ok := C.QStateMachine__SignalEvent_override_virtual_setAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QStateMachine__SignalEvent_setAccepted +func miqt_exec_callback_QStateMachine__SignalEvent_setAccepted(self *C.QStateMachine__SignalEvent, cb C.intptr_t, accepted C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(accepted) + + gofunc((&QStateMachine__SignalEvent{h: self}).callVirtualBase_SetAccepted, slotval1) + +} + +func (this *QStateMachine__SignalEvent) callVirtualBase_Clone() *qt6.QEvent { + + return qt6.UnsafeNewQEvent(unsafe.Pointer(C.QStateMachine__SignalEvent_virtualbase_clone(unsafe.Pointer(this.h)))) + +} +func (this *QStateMachine__SignalEvent) OnClone(slot func(super func() *qt6.QEvent) *qt6.QEvent) { + ok := C.QStateMachine__SignalEvent_override_virtual_clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QStateMachine__SignalEvent_clone +func miqt_exec_callback_QStateMachine__SignalEvent_clone(self *C.QStateMachine__SignalEvent, cb C.intptr_t) *C.QEvent { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *qt6.QEvent) *qt6.QEvent) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QStateMachine__SignalEvent{h: self}).callVirtualBase_Clone) + + return (*C.QEvent)(virtualReturn.UnsafePointer()) + +} + +// Delete this object from C++ memory. +func (this *QStateMachine__SignalEvent) Delete() { + C.QStateMachine__SignalEvent_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 *QStateMachine__SignalEvent) GoGC() { + runtime.SetFinalizer(this, func(this *QStateMachine__SignalEvent) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} + +type QStateMachine__WrappedEvent struct { + h *C.QStateMachine__WrappedEvent + *qt6.QEvent +} + +func (this *QStateMachine__WrappedEvent) cPointer() *C.QStateMachine__WrappedEvent { + if this == nil { + return nil + } + return this.h +} + +func (this *QStateMachine__WrappedEvent) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQStateMachine__WrappedEvent constructs the type using only CGO pointers. +func newQStateMachine__WrappedEvent(h *C.QStateMachine__WrappedEvent) *QStateMachine__WrappedEvent { + if h == nil { + return nil + } + var outptr_QEvent *C.QEvent = nil + C.QStateMachine__WrappedEvent_virtbase(h, &outptr_QEvent) + + return &QStateMachine__WrappedEvent{h: h, + QEvent: qt6.UnsafeNewQEvent(unsafe.Pointer(outptr_QEvent))} +} + +// UnsafeNewQStateMachine__WrappedEvent constructs the type using only unsafe pointers. +func UnsafeNewQStateMachine__WrappedEvent(h unsafe.Pointer) *QStateMachine__WrappedEvent { + return newQStateMachine__WrappedEvent((*C.QStateMachine__WrappedEvent)(h)) +} + +// NewQStateMachine__WrappedEvent constructs a new QStateMachine::WrappedEvent object. +func NewQStateMachine__WrappedEvent(object *qt6.QObject, event *qt6.QEvent) *QStateMachine__WrappedEvent { + + return newQStateMachine__WrappedEvent(C.QStateMachine__WrappedEvent_new((*C.QObject)(object.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) +} + +// NewQStateMachine__WrappedEvent2 constructs a new QStateMachine::WrappedEvent object. +func NewQStateMachine__WrappedEvent2(param1 *QStateMachine__WrappedEvent) *QStateMachine__WrappedEvent { + + return newQStateMachine__WrappedEvent(C.QStateMachine__WrappedEvent_new2(param1.cPointer())) +} + +func (this *QStateMachine__WrappedEvent) Object() *qt6.QObject { + return qt6.UnsafeNewQObject(unsafe.Pointer(C.QStateMachine__WrappedEvent_object(this.h))) +} + +func (this *QStateMachine__WrappedEvent) Event() *qt6.QEvent { + return qt6.UnsafeNewQEvent(unsafe.Pointer(C.QStateMachine__WrappedEvent_event(this.h))) +} + +func (this *QStateMachine__WrappedEvent) OperatorAssign(param1 *QStateMachine__WrappedEvent) { + C.QStateMachine__WrappedEvent_operatorAssign(this.h, param1.cPointer()) +} + +func (this *QStateMachine__WrappedEvent) callVirtualBase_SetAccepted(accepted bool) { + + C.QStateMachine__WrappedEvent_virtualbase_setAccepted(unsafe.Pointer(this.h), (C.bool)(accepted)) + +} +func (this *QStateMachine__WrappedEvent) OnSetAccepted(slot func(super func(accepted bool), accepted bool)) { + ok := C.QStateMachine__WrappedEvent_override_virtual_setAccepted(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QStateMachine__WrappedEvent_setAccepted +func miqt_exec_callback_QStateMachine__WrappedEvent_setAccepted(self *C.QStateMachine__WrappedEvent, cb C.intptr_t, accepted C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(accepted bool), accepted bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (bool)(accepted) + + gofunc((&QStateMachine__WrappedEvent{h: self}).callVirtualBase_SetAccepted, slotval1) + +} + +func (this *QStateMachine__WrappedEvent) callVirtualBase_Clone() *qt6.QEvent { + + return qt6.UnsafeNewQEvent(unsafe.Pointer(C.QStateMachine__WrappedEvent_virtualbase_clone(unsafe.Pointer(this.h)))) + +} +func (this *QStateMachine__WrappedEvent) OnClone(slot func(super func() *qt6.QEvent) *qt6.QEvent) { + ok := C.QStateMachine__WrappedEvent_override_virtual_clone(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QStateMachine__WrappedEvent_clone +func miqt_exec_callback_QStateMachine__WrappedEvent_clone(self *C.QStateMachine__WrappedEvent, cb C.intptr_t) *C.QEvent { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *qt6.QEvent) *qt6.QEvent) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QStateMachine__WrappedEvent{h: self}).callVirtualBase_Clone) + + return (*C.QEvent)(virtualReturn.UnsafePointer()) + +} + +// Delete this object from C++ memory. +func (this *QStateMachine__WrappedEvent) Delete() { + C.QStateMachine__WrappedEvent_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 *QStateMachine__WrappedEvent) GoGC() { + runtime.SetFinalizer(this, func(this *QStateMachine__WrappedEvent) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/statemachine/gen_qstatemachine.h b/qt6/statemachine/gen_qstatemachine.h new file mode 100644 index 000000000..c45d2bb8c --- /dev/null +++ b/qt6/statemachine/gen_qstatemachine.h @@ -0,0 +1,167 @@ +#pragma once +#ifndef MIQT_QT6_STATEMACHINE_GEN_QSTATEMACHINE_H +#define MIQT_QT6_STATEMACHINE_GEN_QSTATEMACHINE_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAbstractAnimation; +class QAbstractState; +class QChildEvent; +class QEvent; +class QMetaMethod; +class QMetaObject; +class QObject; +class QState; +class QStateMachine; +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QStateMachine__SignalEvent) +typedef QStateMachine::SignalEvent QStateMachine__SignalEvent; +#else +class QStateMachine__SignalEvent; +#endif +#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QStateMachine__WrappedEvent) +typedef QStateMachine::WrappedEvent QStateMachine__WrappedEvent; +#else +class QStateMachine__WrappedEvent; +#endif +class QTimerEvent; +class QVariant; +#else +typedef struct QAbstractAnimation QAbstractAnimation; +typedef struct QAbstractState QAbstractState; +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QObject QObject; +typedef struct QState QState; +typedef struct QStateMachine QStateMachine; +typedef struct QStateMachine__SignalEvent QStateMachine__SignalEvent; +typedef struct QStateMachine__WrappedEvent QStateMachine__WrappedEvent; +typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; +#endif + +QStateMachine* QStateMachine_new(); +QStateMachine* QStateMachine_new2(int childMode); +QStateMachine* QStateMachine_new3(QObject* parent); +QStateMachine* QStateMachine_new4(int childMode, QObject* parent); +void QStateMachine_virtbase(QStateMachine* src, QState** outptr_QState); +QMetaObject* QStateMachine_metaObject(const QStateMachine* self); +void* QStateMachine_metacast(QStateMachine* self, const char* param1); +struct miqt_string QStateMachine_tr(const char* s); +void QStateMachine_addState(QStateMachine* self, QAbstractState* state); +void QStateMachine_removeState(QStateMachine* self, QAbstractState* state); +int QStateMachine_error(const QStateMachine* self); +struct miqt_string QStateMachine_errorString(const QStateMachine* self); +void QStateMachine_clearError(QStateMachine* self); +bool QStateMachine_isRunning(const QStateMachine* self); +bool QStateMachine_isAnimated(const QStateMachine* self); +void QStateMachine_setAnimated(QStateMachine* self, bool enabled); +void QStateMachine_addDefaultAnimation(QStateMachine* self, QAbstractAnimation* animation); +struct miqt_array /* of QAbstractAnimation* */ QStateMachine_defaultAnimations(const QStateMachine* self); +void QStateMachine_removeDefaultAnimation(QStateMachine* self, QAbstractAnimation* animation); +int QStateMachine_globalRestorePolicy(const QStateMachine* self); +void QStateMachine_setGlobalRestorePolicy(QStateMachine* self, int restorePolicy); +void QStateMachine_postEvent(QStateMachine* self, QEvent* event); +int QStateMachine_postDelayedEvent(QStateMachine* self, QEvent* event, int delay); +bool QStateMachine_cancelDelayedEvent(QStateMachine* self, int id); +struct miqt_array /* set of QAbstractState* */ QStateMachine_configuration(const QStateMachine* self); +bool QStateMachine_eventFilter(QStateMachine* self, QObject* watched, QEvent* event); +void QStateMachine_start(QStateMachine* self); +void QStateMachine_stop(QStateMachine* self); +void QStateMachine_setRunning(QStateMachine* self, bool running); +void QStateMachine_runningChanged(QStateMachine* self, bool running); +void QStateMachine_connect_runningChanged(QStateMachine* self, intptr_t slot); +void QStateMachine_onEntry(QStateMachine* self, QEvent* event); +void QStateMachine_onExit(QStateMachine* self, QEvent* event); +void QStateMachine_beginSelectTransitions(QStateMachine* self, QEvent* event); +void QStateMachine_endSelectTransitions(QStateMachine* self, QEvent* event); +void QStateMachine_beginMicrostep(QStateMachine* self, QEvent* event); +void QStateMachine_endMicrostep(QStateMachine* self, QEvent* event); +bool QStateMachine_event(QStateMachine* self, QEvent* e); +struct miqt_string QStateMachine_tr2(const char* s, const char* c); +struct miqt_string QStateMachine_tr3(const char* s, const char* c, int n); +void QStateMachine_postEvent2(QStateMachine* self, QEvent* event, int priority); + +bool QStateMachine_override_virtual_eventFilter(void* self, intptr_t slot); +bool QStateMachine_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QStateMachine_override_virtual_onEntry(void* self, intptr_t slot); +void QStateMachine_virtualbase_onEntry(void* self, QEvent* event); +bool QStateMachine_override_virtual_onExit(void* self, intptr_t slot); +void QStateMachine_virtualbase_onExit(void* self, QEvent* event); +bool QStateMachine_override_virtual_beginSelectTransitions(void* self, intptr_t slot); +void QStateMachine_virtualbase_beginSelectTransitions(void* self, QEvent* event); +bool QStateMachine_override_virtual_endSelectTransitions(void* self, intptr_t slot); +void QStateMachine_virtualbase_endSelectTransitions(void* self, QEvent* event); +bool QStateMachine_override_virtual_beginMicrostep(void* self, intptr_t slot); +void QStateMachine_virtualbase_beginMicrostep(void* self, QEvent* event); +bool QStateMachine_override_virtual_endMicrostep(void* self, intptr_t slot); +void QStateMachine_virtualbase_endMicrostep(void* self, QEvent* event); +bool QStateMachine_override_virtual_event(void* self, intptr_t slot); +bool QStateMachine_virtualbase_event(void* self, QEvent* e); +bool QStateMachine_override_virtual_timerEvent(void* self, intptr_t slot); +void QStateMachine_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QStateMachine_override_virtual_childEvent(void* self, intptr_t slot); +void QStateMachine_virtualbase_childEvent(void* self, QChildEvent* event); +bool QStateMachine_override_virtual_customEvent(void* self, intptr_t slot); +void QStateMachine_virtualbase_customEvent(void* self, QEvent* event); +bool QStateMachine_override_virtual_connectNotify(void* self, intptr_t slot); +void QStateMachine_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QStateMachine_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QStateMachine_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QStateMachine_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QStateMachine_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QStateMachine_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QStateMachine_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QStateMachine_connect_started(QStateMachine* self, intptr_t slot); +void QStateMachine_connect_stopped(QStateMachine* self, intptr_t slot); + +void QStateMachine_delete(QStateMachine* self); + +QStateMachine__SignalEvent* QStateMachine__SignalEvent_new(QObject* sender, int signalIndex, struct miqt_array /* of QVariant* */ arguments); +QStateMachine__SignalEvent* QStateMachine__SignalEvent_new2(QStateMachine__SignalEvent* param1); +void QStateMachine__SignalEvent_virtbase(QStateMachine__SignalEvent* src, QEvent** outptr_QEvent); +QObject* QStateMachine__SignalEvent_sender(const QStateMachine__SignalEvent* self); +int QStateMachine__SignalEvent_signalIndex(const QStateMachine__SignalEvent* self); +struct miqt_array /* of QVariant* */ QStateMachine__SignalEvent_arguments(const QStateMachine__SignalEvent* self); +void QStateMachine__SignalEvent_operatorAssign(QStateMachine__SignalEvent* self, QStateMachine__SignalEvent* param1); + +bool QStateMachine__SignalEvent_override_virtual_setAccepted(void* self, intptr_t slot); +void QStateMachine__SignalEvent_virtualbase_setAccepted(void* self, bool accepted); +bool QStateMachine__SignalEvent_override_virtual_clone(void* self, intptr_t slot); +QEvent* QStateMachine__SignalEvent_virtualbase_clone(const void* self); + +void QStateMachine__SignalEvent_delete(QStateMachine__SignalEvent* self); + +QStateMachine__WrappedEvent* QStateMachine__WrappedEvent_new(QObject* object, QEvent* event); +QStateMachine__WrappedEvent* QStateMachine__WrappedEvent_new2(QStateMachine__WrappedEvent* param1); +void QStateMachine__WrappedEvent_virtbase(QStateMachine__WrappedEvent* src, QEvent** outptr_QEvent); +QObject* QStateMachine__WrappedEvent_object(const QStateMachine__WrappedEvent* self); +QEvent* QStateMachine__WrappedEvent_event(const QStateMachine__WrappedEvent* self); +void QStateMachine__WrappedEvent_operatorAssign(QStateMachine__WrappedEvent* self, QStateMachine__WrappedEvent* param1); + +bool QStateMachine__WrappedEvent_override_virtual_setAccepted(void* self, intptr_t slot); +void QStateMachine__WrappedEvent_virtualbase_setAccepted(void* self, bool accepted); +bool QStateMachine__WrappedEvent_override_virtual_clone(void* self, intptr_t slot); +QEvent* QStateMachine__WrappedEvent_virtualbase_clone(const void* self); + +void QStateMachine__WrappedEvent_delete(QStateMachine__WrappedEvent* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif From 6b8ee020df658fdfa97a2292a94fcbe4323703ff Mon Sep 17 00:00:00 2001 From: Vladimir Kononov Date: Sun, 11 Jan 2026 00:51:56 +0300 Subject: [PATCH 04/12] Add simple qt6 statemachine example --- examples/libraries/qt6-statemachine/main.go | 22 +++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 examples/libraries/qt6-statemachine/main.go diff --git a/examples/libraries/qt6-statemachine/main.go b/examples/libraries/qt6-statemachine/main.go new file mode 100644 index 000000000..b771165ce --- /dev/null +++ b/examples/libraries/qt6-statemachine/main.go @@ -0,0 +1,22 @@ +package main + +import ( + "os" + + qt "github.com/mappu/miqt/qt6" + "github.com/mappu/miqt/qt6/statemachine" +) + +func main() { + _ = qt.NewQApplication(os.Args) + + sm := statemachine.NewQStateMachine() + state1 := statemachine.NewQState() + state2 := statemachine.NewQState() + sm.AddState(state1.QAbstractState) + sm.AddState(state2.QAbstractState) + sm.SetInitialState(state1.QAbstractState) + state1.AddTransitionWithTarget(state2.QAbstractState) + sm.Start() + qt.QApplication_Exec() +} From e0946322034afe20460e9e4dd87440499066af55 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sat, 31 Jan 2026 01:27:51 -0500 Subject: [PATCH 05/12] qt6-scxml: Update cflags.go --- qt6/scxml/cflags.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qt6/scxml/cflags.go b/qt6/scxml/cflags.go index 47a41cb0b..256f6c91b 100644 --- a/qt6/scxml/cflags.go +++ b/qt6/scxml/cflags.go @@ -1,4 +1,4 @@ -package statemachine +package scxml /* #cgo pkg-config: Qt6Scxml Qt6ScxmlQml From 7b9b2edf11093c9d6590c2d184465d903d605dae Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sat, 31 Jan 2026 00:47:44 -0500 Subject: [PATCH 06/12] Add Qt 6 State Machine example Ref: https://doc.qt.io/qt-6/qtstatemachine-trafficlight-example.html * Closes #299 --- examples/libraries/qt6-statemachine/main.go | 177 +++++++++++++++++- .../libraries/qt6-statemachine/screenshot.png | Bin 0 -> 7024 bytes 2 files changed, 167 insertions(+), 10 deletions(-) create mode 100644 examples/libraries/qt6-statemachine/screenshot.png diff --git a/examples/libraries/qt6-statemachine/main.go b/examples/libraries/qt6-statemachine/main.go index b771165ce..b62d08d1c 100644 --- a/examples/libraries/qt6-statemachine/main.go +++ b/examples/libraries/qt6-statemachine/main.go @@ -1,22 +1,179 @@ package main import ( + "math" "os" qt "github.com/mappu/miqt/qt6" "github.com/mappu/miqt/qt6/statemachine" ) +type LightWidget struct { + color qt.GlobalColor + on bool + widget *qt.QWidget +} + +type TrafficWidget struct { + red *LightWidget + yellow *LightWidget + green *LightWidget + widget *qt.QWidget +} + +func NewLightWidget(color qt.GlobalColor) *LightWidget { + var self LightWidget + + self.color = color + self.on = false + self.widget = qt.NewQWidget2() + + self.widget.OnPaintEvent(func(super func(event *qt.QPaintEvent), event *qt.QPaintEvent) { + if !self.on { + return + } + + painter := qt.NewQPainter2(self.widget.QPaintDevice) + defer painter.Delete() + + brush := qt.NewQBrush4(self.color) + defer brush.Delete() + + painter.SetRenderHint(qt.QPainter__Antialiasing) + painter.SetBrush(brush) + + height := self.widget.Height() + width := self.widget.Width() + minVal := int(math.Min(float64(height), float64(width))) + size := (minVal * 2) / 3 + x := (width - size) / 2 + y := (height - size) / 2 + + painter.DrawEllipse2(x, y, size, size) + }) + + return &self +} + +func (this *LightWidget) IsOn() bool { + return this.on +} + +func (this *LightWidget) SetOn(on bool) { + if this.on == on { + return + } + + this.on = on + + this.widget.Update() +} + +func (this *LightWidget) TurnOff() { + this.SetOn(false) +} + +func (this *LightWidget) TurnOn() { + this.SetOn(true) +} + +func NewTrafficWidget() *TrafficWidget { + var self TrafficWidget + + self.red = NewLightWidget(qt.Red) + self.yellow = NewLightWidget(qt.Yellow) + self.green = NewLightWidget(qt.Green) + + self.widget = qt.NewQWidget2() + + layout := qt.NewQVBoxLayout(self.widget) + layout.AddWidget(self.red.widget) + layout.AddWidget(self.yellow.widget) + layout.AddWidget(self.green.widget) + + palette := qt.NewQPalette() + defer palette.Delete() + + color := qt.NewQColor2(qt.Black) + defer color.Delete() + + palette.SetColor2(qt.QPalette__Window, color) + self.widget.SetPalette(palette) + self.widget.SetAutoFillBackground(true) + + return &self +} + +func (this *TrafficWidget) RedLight() *LightWidget { + return this.red +} + +func (this *TrafficWidget) YellowLight() *LightWidget { + return this.yellow +} + +func (this *TrafficWidget) GreenLight() *LightWidget { + return this.green +} + +func CreateLightState(light *LightWidget, duration int) *statemachine.QState { + lightState := statemachine.NewQState() + timing := statemachine.NewQState3(lightState) + + timer := qt.NewQTimer2(lightState.QObject) + timer.SetInterval(duration) + timer.SetSingleShot(true) + + timing.OnEntered(func() { + light.TurnOn() + timer.Start2() + }) + + timing.OnExited(func() { + light.TurnOff() + }) + + done := statemachine.NewQFinalState2(lightState) + timing.AddTransition2(timer.QObject, "timeout()", done.QAbstractState) + + lightState.SetInitialState(timing.QAbstractState) + + return lightState +} + func main() { - _ = qt.NewQApplication(os.Args) - - sm := statemachine.NewQStateMachine() - state1 := statemachine.NewQState() - state2 := statemachine.NewQState() - sm.AddState(state1.QAbstractState) - sm.AddState(state2.QAbstractState) - sm.SetInitialState(state1.QAbstractState) - state1.AddTransitionWithTarget(state2.QAbstractState) - sm.Start() + qt.NewQApplication(os.Args) + + trafficLight := qt.NewQWidget2() + defer trafficLight.Delete() + + trafficLight.SetWindowTitle("Qt 6 State Machine Example") + trafficLight.Resize(300, 800) + trafficLight.SetMinimumHeight(450) + trafficLight.SetMinimumWidth(200) + + layout := qt.NewQVBoxLayout(trafficLight) + trafficWidget := NewTrafficWidget() + + layout.AddWidget(trafficWidget.widget) + layout.SetContentsMargins(0, 0, 0, 0) + + redGoingGreen := CreateLightState(trafficWidget.RedLight(), 3000) + greenGoingYellow := CreateLightState(trafficWidget.GreenLight(), 3000) + yellowGoingRed := CreateLightState(trafficWidget.YellowLight(), 1000) + + redGoingGreen.AddTransition2(redGoingGreen.QObject, "finished()", greenGoingYellow.QAbstractState) + greenGoingYellow.AddTransition2(greenGoingYellow.QObject, "finished()", yellowGoingRed.QAbstractState) + yellowGoingRed.AddTransition2(yellowGoingRed.QObject, "finished()", redGoingGreen.QAbstractState) + + machine := statemachine.NewQStateMachine3(trafficLight.QObject) + machine.AddState(redGoingGreen.QAbstractState) + machine.AddState(greenGoingYellow.QAbstractState) + machine.AddState(yellowGoingRed.QAbstractState) + machine.SetInitialState(redGoingGreen.QAbstractState) + machine.Start() + + trafficLight.Show() + qt.QApplication_Exec() } diff --git a/examples/libraries/qt6-statemachine/screenshot.png b/examples/libraries/qt6-statemachine/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..4ac366e10aafc403ac27056417c91af1ee16cf01 GIT binary patch literal 7024 zcmeHMXH*kiw?qFRR|y@AWBg{N`TOtBot|a6sZvr zkrpJOw>~i+(^~{==mgdHsY?s&=7#KJ~ zz&j8IhEsA33`_=R8R-(?<~|wvz;4e(q?;tK!n>15|<7qyZj$@$?+_@p4bCiy%+ zzccy*AK#DdurtLwnHd>BfBm9g_h^w&D=RBgQ`4*GuFJ_a`pzQMKU|O-Oh`&fdik<{ zczD|pZF~2w>Hevp{^m6Tfnad;+jf|)UQr6$>7=*5v((-23WE=FDHMjMRnyI8JdANx zF;Csji{29eoE2Eo#*+$>JJVi%9(#Yjcb|RUvo~`Txmcv&^2dRyTm?3TRf>)XhIH)g zMmpAQ38;%_+3pR*^Z=Jly53X&Xh@kA=pk1yErt7Q92i;RVv{|Xc#w-yC%`Kz0W0=!=y4~>Q7YW6xO`(c>iEf~bpdY;AI{&gIiU;}FbKafWjWO# z^LW$Q90Z~e%Pk%}crdLmE+!VXy%MyP1G6J{^<8GYeLv#e;tXd5CC3|CbxbX=C#+@2 zh9N|DAT%B(sB5-wIBI5YtljxwNjgxK=>qj@@CT^T@#mJscc3VjziV%v^{At#C?#o3 zv&UP#@3SsalOHZ%p(Ec%nBzFE;70Y9%4BZtxZ4)akTwToA$pODx>rFH(zve8j}J}8 zTVb}V$jfBp_IUL0{tY1qaLcg3-=*pT569KHBxJ2%iQM2N<@=wMPY|g1u+TF*6e8?n z3~RG*mhHWFp2OG7^WTU5UHU`%;&Pcfnlo~w9klqI`{-{J7A0Xp%v*02h3_vP#z(dOuIL$@-CJFH+*`G9Gz$yd z!~%YAz7}cKs~xT6Cv6$^nwbsZw$?>MLg4dCDvE*qQvOMWjkV)FB6c0!dqS}Jn~%O0 z;QWN4jmUji9Zu!(FCOCnN{VyHjkUSfeU=~UXs}&CAD+DAOR@`anua3FLvBVKk{--9 zthB7@KKSs;H}BI$A7{Po;ZZ)jRr&VErRKLk>qLeoX0J9Cb!crC4F>)$BK=yLZHUa) z(cXw=EmZ&&?fZTNtXaG7)EusklSz(f59fNAh<;uH&UcM~6=Z>)>oD^R-yaT7*Nb}i zfuy0neq(9dHCJtUH+@r4Q>A40DEbGqEu!y;x~Q=COK`OH@`$Lry2{_Itq^vo1ZyeDXBNhjI1@zhCJ;;Q;{hyAXVC=V-G;KXI>O?eM{k_hDb&x(=&I z;gnW;Q<^oX`(xBv;9H6Q1pnZJ!pc(P&d!R)?X}&xuUmhPH^=;WTUTE7MV_qkYvPuJ zsoQ3{c7~bL4?<}?9!Gk0wrxQxvm!9Hj{1|Jn!0sT%`|?bFS1c{Uw~DzpD)Wsi8^i^ zmkb{Co(_6+GKQ_w(Rng93GiL-C^r#LkqG5o5y{>ri#|6p9qcS7xzlFv2#0<3I$d=+ z+Ta_7?ODTcf4Wqby_1)hm*W}mz|c^>iU&9|gnJ`aP*z5L#+^+5m5D=~+1w?w=+xI+ z0S<##=b&=hQPdrm)?e)W3q*5^oiOnuL3d+wynf5%SH0WJ)rU(tjn5U^_GK3?9V}1i zA^nApz;*FE)kU<8_8)qVP33>yn)S+u9gf~`%+px=(h{)b+l7VxFscVsanIk28XKRy zi+;a$5|?5!Yq>Z*y_(z7<`V4s=_oe#Lg3-90?>JKJGsgU*X|dTZeC#Bf_c^dF!;G7 zC>TFFyX({X{x4uO?=$YO|5;6RtYB~O zH9c5v0nKw=%zNiGIqY)jTKMm#3YEONP*VNLx-3X$_({}PhvXw1!I|{rG*)r6GS+ z@YVv$N#}7+qJrOg-cF$Y#G&oDwtU0|etwJmoAn{og$ovps;a6|rrDMb4%>ko8PCx%taAYyLgWjNQhHGloP+CELBViPrJTQHpp^Exw;rML7B?C)J&zA96r=Xt4Nz<$ zFf@1os*ChodWEzOF+aHvN|v{+XTca;z1l99&3MWg-6w846)%II$t!)ox7l5*r7ho4 zFx03%#_!3dfjmS~u)YdjOVG}G2NX4_ng3eWv68QQG@=?NG}Resakcpt?V(9)vz#Ma z1~b=AWBCSWR7A(%v9!gjoV-qN+A3@54=0N&dsR^Nun-#hw)2bDtz)Uf#%%4yXnnaE zV)5*9NM!gY@u}8n&1k~bNSyvjZ*q}EHQSD-$YZ5YTH)#$)r+K)uR$~&*!am(=d`{f ze|QbJ#UBP+V|OUepZQSgdrEe_+GIup@1*WeWTn=uJb1?*Li48`Bqf+QvSuwrB8eTy z)^b%NrT~Yg$Kl_I1AFnRGru}vCWFxukpSuat=9GJ9;+vX6JH#Q#;7DCG#f4 z2IpYhwNTRQGrxY^y+u2zB4;tRLH4U+TEyHUq&5&Z>Zjzm~<(~R`(jJ?dZAhj4Hsb4(C|M=E!7NCKTfxno^GpC!rh%+2ig;*-y%!Opm@DMD8{XM*LdOJ@2-&DD%!y`PGQ` zZhQN!s zon_TQ8C$7Ld*RDAe+WNu|}wqc9dG656%d!zHwa8g|h zG-P~6&?LZD@=AnWYal7Kb2x3bMPv9$(1XoXmN32TyAS*hP*Hj`qZ!xPynw}UZ|drs zhS1AU)vbN+$YbOF&l`#gwC(M3pGzlOlX;1t zbR}xDQ~=N!*T>VD!R$#FT|IoG)eI6cd2_CIyRCqPDa`OTib|E|p<$crCUD!7s`U-C zhmC_=hUeS(wAFfjO~6C}`GMsokwk62o62b@Xq)|vXIttsLNhSLga?A52(jD9JE7EU zX8hX%o-G7mx>1qyGHB+|iTC|g|Bq1GTk)Yh!6Mb6@TShP`8!Szpy-wk{ zR-uGPEn?fvCZBgtKoiI`j%;43Ce%c(0@DxQCPedjSey1Y1&`m`?q(u1(eZ^0iG9;x z_PgSaZSz|^A`La|89r^#zdaD{7nfH-7RNt1q;?}?SAJmHobF@MgaD%QM}RXty^(}S zderT0H_nUcw)ytbK~(p;WNz{)sXt&>co#*}HM?1ph5YBHURh~oLgozUooV0M5PRTY zPOdP2opm4j>OA-ibB_db~9Q+5d=cVPpBiXa~-8$3^ z!agE6CcPBb&=a88vh)v04wWesYw=w9dCGymU@)br)U}ey9vhpKOkk`WLvUEnImaBi zLV+8=W(r5y`whnR)9_>p$IXv&()|c#>$@#V))to}<~_8SlT&5Z((Kwd`*`PX2yFxT z!GorK1|Bm&Z_HDQK+sSSV0q@<$)oSJ;t*67o;4jCTc%nJ{yV?h`O;6?5H|)o$fO8V z5Ii6(S;&;PiOf-xwNK*?_FE=XHXZz&j}dH?3eM zq;_{5#4%7n3i&{b$?IN%H}mayemBgRnHD|zu@7em@{kz12Oqu@N6R2>bl(M~2^Wci zUU})p9|hpWbODGPs9dHxrY@Bd6KU`IVp&J897_H<#s0n&Ym7B7bN}}90&q}>HmXWj zI0e(!oxF~IeFbUTqB_DVjxDh%w%)@=C%aw?T8duDYQQ)UmCwmdLmC2c+yl|#CD67+ zHU#=~W%*AHp;GkCM-nk(}e)CxpjT!F+`5i;p}hQBKb$ittz z!=)*el)+{SGjK^rO)!I)`2Czf54!mgOF#QWJQdOiIELJgDetHqG?&`rzWZ48p<0Ha=}`r(DT z`Tpv|DSo&7u>l0Lz$iFDwLtXx$F8%T5EG){y*nmGAJ18R0WRCsI0$j_utMHYIFw#% z5=YO~lMoC78SYvJmUOI5u97^>(%qh}vjxhcw}x;2>-L8k%hOx&Cwxt2fc9$`{^gN2K zCMww<;OTkU5UMH_eSOCXuEmt(K*>n^%BuegEwOf^;8c)en#S+j#=<1M6}`j!&F$F$ zBc4Jr+C6$fOmTA^U|proyP?$v>D5;62tiXgx))=_bgm-3{&`+bIQ6gHVpm0pVHxQ) zm33t9cqvoW$Pi>jP@&IZ7d3yq8CBtu{>TK$rEpZJ!ntx22b2L05=c)vzz~cpEXpuh zQ!3+U&{q&+@`(5}J%+T~^z|bKx^GmFf`&bIS_Uw=ffL#1JM6%3B9||WOpladKfRvO>z!<^?Wh|3=ROVi+ zekFCW;63wtMVcifX-ko=WODpZ#adp@SLX${88~^+yTom8cnyW4sT(d{f^i|(5e3g7 z1o5=v({&VvZu_eqAdQ^l=x>+A=Ejl$U_18aKX0}pM4TMyG#pK|0-@E0 z5X`4Xm0&J%VW(lqF(|ppskC>#yV4o=u@IuNSBiTI;bA3^-k6!q7nI;Rd?aBx@>H57 z%0h zO?SMyu91j{)B5&@9$kkT)XSF+JqE5!=hIhxtVZT9k!<>=!O>$GNMSL?={n%Q)4goo zD&0cUTcv0nsC~{VI-m#WfS1%=VUUDih$M8ymwjszt722?3Q^6oFJkdn3Wje^_MLg=nc|M-DrU+po79_q+lc05PiT-}8p3!8P zUqSEP6sAe#n)r-+ZMSdd;d-v?wJ2|h$|PTYay*4s4D3chscP zNsw6x%iRGKFQ(lzE4q8a7<}(B_h$eY22{+hjo0!U0hwXW617EcO4x0JqcRdqvy5w+ z87YtZ#e1_CzJI6(mq zG)QBHR8y88noe51_HQpAVni^GgmQvdWg+5e(P_0;|E9sl2`DF^FUAgHQkgl{L8rkI z|3ibRSi{QbMtiMuL#sEX&%3?Y6uLVqow10yB5jwD&db&OMEVvulR)R$#shj&0a%^N z!VEa12*4JPBq5}Smg(6(f_A0Fn|E&cWMpqJ^L?H CZefN1 literal 0 HcmV?d00001 From f74e8a84bce0d51feeed7aae2074d84386fe0f5c Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sat, 31 Jan 2026 00:48:03 -0500 Subject: [PATCH 07/12] .gitignore: Add qt6-statemachine --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index a3d7d2caf..483c79d7f 100644 --- a/.gitignore +++ b/.gitignore @@ -47,6 +47,7 @@ examples/libraries/qt6-network-sctp/qt6-network-sctp examples/libraries/qt6-network/qt6-network examples/libraries/qt6-pdf/qt6-pdf examples/libraries/qt6-positioning/qt6-positioning +examples/libraries/qt6-statemachine/qt6-statemachine examples/libraries/qt6-uitools/qt6-uitools examples/libraries/qt6-webengine/qt6-webengine examples/libraries/restricted-extras-charts6/restricted-extras-charts6 From 55c286b635e5cf5c4e0dc8151fc1ccb1264081c0 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sat, 31 Jan 2026 05:48:31 -0500 Subject: [PATCH 08/12] config-allowlist.go: Block QScxmlCompiler::Loader::load --- cmd/genbindings/config-allowlist.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/cmd/genbindings/config-allowlist.go b/cmd/genbindings/config-allowlist.go index 5d0824ed8..faed9681a 100644 --- a/cmd/genbindings/config-allowlist.go +++ b/cmd/genbindings/config-allowlist.go @@ -421,6 +421,10 @@ func AllowMethod(className string, mm CppMethod) error { return ErrTooComplex // Callbacks that the attached object types must provide to QML } + if className == "QScxmlCompiler::Loader" && mm.MethodName == "load" { + return ErrTooComplex // A pure virtual method that takes a pointer to QStringList as a parameter type + } + // Skip functions that return ints-by-reference since the ergonomics don't // go through the binding if mm.ReturnType.IntType() && mm.ReturnType.ByRef { From b828f5e21d28d15207005724806f6f74e5270306 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sat, 31 Jan 2026 05:49:47 -0500 Subject: [PATCH 09/12] qt: Rebuild (Remove QScxmlCompiler::Loader::load) --- qt6/scxml/gen_qscxmlcompiler.cpp | 88 +------------------------------- qt6/scxml/gen_qscxmlcompiler.go | 72 -------------------------- qt6/scxml/gen_qscxmlcompiler.h | 4 -- 3 files changed, 1 insertion(+), 163 deletions(-) diff --git a/qt6/scxml/gen_qscxmlcompiler.cpp b/qt6/scxml/gen_qscxmlcompiler.cpp index 3fcbf99d8..5da0979f6 100644 --- a/qt6/scxml/gen_qscxmlcompiler.cpp +++ b/qt6/scxml/gen_qscxmlcompiler.cpp @@ -1,4 +1,3 @@ -#include #include #include #define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlCompiler__Loader @@ -15,7 +14,6 @@ extern "C" { #endif -struct miqt_string miqt_exec_callback_QScxmlCompiler__Loader_load(QScxmlCompiler__Loader*, intptr_t, struct miqt_string, struct miqt_string, struct miqt_array /* of struct miqt_string */ ); #ifdef __cplusplus } /* extern C */ #endif @@ -69,98 +67,14 @@ void QScxmlCompiler_delete(QScxmlCompiler* self) { delete self; } -class MiqtVirtualQScxmlCompilerLoader final : public QScxmlCompiler::Loader { -public: - - MiqtVirtualQScxmlCompilerLoader(): QScxmlCompiler::Loader() {} - - virtual ~MiqtVirtualQScxmlCompilerLoader() override = default; - - // cgo.Handle value for overwritten implementation - intptr_t handle__load = 0; - - // Subclass to allow providing a Go implementation - virtual QByteArray load(const QString& name, const QString& baseDir, QStringList* errors) override { - if (handle__load == 0) { - return QByteArray(); // Pure virtual, there is no base we can call - } - - const QString name_ret = name; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray name_b = name_ret.toUtf8(); - struct miqt_string name_ms; - name_ms.len = name_b.length(); - name_ms.data = static_cast(malloc(name_ms.len)); - memcpy(name_ms.data, name_b.data(), name_ms.len); - struct miqt_string sigval1 = name_ms; - const QString baseDir_ret = baseDir; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray baseDir_b = baseDir_ret.toUtf8(); - struct miqt_string baseDir_ms; - baseDir_ms.len = baseDir_b.length(); - baseDir_ms.data = static_cast(malloc(baseDir_ms.len)); - memcpy(baseDir_ms.data, baseDir_b.data(), baseDir_ms.len); - struct miqt_string sigval2 = baseDir_ms; - QStringList* errors_ret = errors; - // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* errors_arr = static_cast(malloc(sizeof(struct miqt_string) * errors_ret.length())); - for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { - QString errors_lv_ret = errors_ret[i]; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray errors_lv_b = errors_lv_ret.toUtf8(); - struct miqt_string errors_lv_ms; - errors_lv_ms.len = errors_lv_b.length(); - errors_lv_ms.data = static_cast(malloc(errors_lv_ms.len)); - memcpy(errors_lv_ms.data, errors_lv_b.data(), errors_lv_ms.len); - errors_arr[i] = errors_lv_ms; - } - struct miqt_array errors_out; - errors_out.len = errors_ret.length(); - errors_out.data = static_cast(errors_arr); - struct miqt_array /* of struct miqt_string */ sigval3 = errors_out; - struct miqt_string callback_return_value = miqt_exec_callback_QScxmlCompiler__Loader_load(this, handle__load, sigval1, sigval2, sigval3); - QByteArray callback_return_value_QByteArray(callback_return_value.data, callback_return_value.len); - return callback_return_value_QByteArray; - } - -}; - QScxmlCompiler__Loader* QScxmlCompiler__Loader_new() { - return new (std::nothrow) MiqtVirtualQScxmlCompilerLoader(); -} - -struct miqt_string QScxmlCompiler__Loader_load(QScxmlCompiler__Loader* self, struct miqt_string name, struct miqt_string baseDir, struct miqt_array /* of struct miqt_string */ errors) { - QString name_QString = QString::fromUtf8(name.data, name.len); - QString baseDir_QString = QString::fromUtf8(baseDir.data, baseDir.len); - QStringList errors_QList; - errors_QList.reserve(errors.len); - struct miqt_string* errors_arr = static_cast(errors.data); - for(size_t i = 0; i < errors.len; ++i) { - QString errors_arr_i_QString = QString::fromUtf8(errors_arr[i].data, errors_arr[i].len); - errors_QList.push_back(errors_arr_i_QString); - } - QByteArray _qb = self->load(name_QString, baseDir_QString, &errors_QList); - struct miqt_string _ms; - _ms.len = _qb.length(); - _ms.data = static_cast(malloc(_ms.len)); - memcpy(_ms.data, _qb.data(), _ms.len); - return _ms; + return new (std::nothrow) QScxmlCompiler::Loader(); } void QScxmlCompiler__Loader_operatorAssign(QScxmlCompiler__Loader* self, QScxmlCompiler__Loader* param1) { self->operator=(*param1); } -bool QScxmlCompiler__Loader_override_virtual_load(void* self, intptr_t slot) { - MiqtVirtualQScxmlCompilerLoader* self_cast = dynamic_cast( (QScxmlCompiler::Loader*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__load = slot; - return true; -} - void QScxmlCompiler__Loader_delete(QScxmlCompiler__Loader* self) { delete self; } diff --git a/qt6/scxml/gen_qscxmlcompiler.go b/qt6/scxml/gen_qscxmlcompiler.go index cc31e27d8..4734608bb 100644 --- a/qt6/scxml/gen_qscxmlcompiler.go +++ b/qt6/scxml/gen_qscxmlcompiler.go @@ -11,7 +11,6 @@ import "C" import ( "github.com/mappu/miqt/qt6" "runtime" - "runtime/cgo" "unsafe" ) @@ -144,80 +143,9 @@ func NewQScxmlCompiler__Loader() *QScxmlCompiler__Loader { return newQScxmlCompiler__Loader(C.QScxmlCompiler__Loader_new()) } -func (this *QScxmlCompiler__Loader) Load(name string, baseDir string, errors []string) []byte { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - baseDir_ms := C.struct_miqt_string{} - baseDir_ms.data = C.CString(baseDir) - baseDir_ms.len = C.size_t(len(baseDir)) - defer C.free(unsafe.Pointer(baseDir_ms.data)) - errors_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(errors)))) - defer C.free(unsafe.Pointer(errors_CArray)) - for i := range errors { - errors_i_ms := C.struct_miqt_string{} - errors_i_ms.data = C.CString(errors[i]) - errors_i_ms.len = C.size_t(len(errors[i])) - defer C.free(unsafe.Pointer(errors_i_ms.data)) - errors_CArray[i] = errors_i_ms - } - errors_ma := C.struct_miqt_array{len: C.size_t(len(errors)), data: unsafe.Pointer(errors_CArray)} - var _bytearray C.struct_miqt_string = C.QScxmlCompiler__Loader_load(this.h, name_ms, baseDir_ms, errors_ma) - _ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len))) - C.free(unsafe.Pointer(_bytearray.data)) - return _ret -} - func (this *QScxmlCompiler__Loader) OperatorAssign(param1 *QScxmlCompiler__Loader) { C.QScxmlCompiler__Loader_operatorAssign(this.h, param1.cPointer()) } -func (this *QScxmlCompiler__Loader) OnLoad(slot func(name string, baseDir string, errors []string) []byte) { - ok := C.QScxmlCompiler__Loader_override_virtual_load(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCompiler__Loader_load -func miqt_exec_callback_QScxmlCompiler__Loader_load(self *C.QScxmlCompiler__Loader, cb C.intptr_t, name C.struct_miqt_string, baseDir C.struct_miqt_string, errors C.struct_miqt_array) C.struct_miqt_string { - gofunc, ok := cgo.Handle(cb).Value().(func(name string, baseDir string, errors []string) []byte) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var name_ms C.struct_miqt_string = name - name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) - C.free(unsafe.Pointer(name_ms.data)) - slotval1 := name_ret - var baseDir_ms C.struct_miqt_string = baseDir - baseDir_ret := C.GoStringN(baseDir_ms.data, C.int(int64(baseDir_ms.len))) - C.free(unsafe.Pointer(baseDir_ms.data)) - slotval2 := baseDir_ret - var errors_ma C.struct_miqt_array = errors - errors_ret := make([]string, int(errors_ma.len)) - errors_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(errors_ma.data)) // hey ya - for i := 0; i < int(errors_ma.len); i++ { - var errors_lv_ms C.struct_miqt_string = errors_outCast[i] - errors_lv_ret := C.GoStringN(errors_lv_ms.data, C.int(int64(errors_lv_ms.len))) - C.free(unsafe.Pointer(errors_lv_ms.data)) - errors_ret[i] = errors_lv_ret - } - slotval3 := errors_ret - - virtualReturn := gofunc(slotval1, slotval2, slotval3) - virtualReturn_alias := C.struct_miqt_string{} - if len(virtualReturn) > 0 { - virtualReturn_alias.data = (*C.char)(unsafe.Pointer(&virtualReturn[0])) - } else { - virtualReturn_alias.data = (*C.char)(unsafe.Pointer(nil)) - } - virtualReturn_alias.len = C.size_t(len(virtualReturn)) - - return virtualReturn_alias - -} // Delete this object from C++ memory. func (this *QScxmlCompiler__Loader) Delete() { diff --git a/qt6/scxml/gen_qscxmlcompiler.h b/qt6/scxml/gen_qscxmlcompiler.h index 3a77b63a5..84b13490c 100644 --- a/qt6/scxml/gen_qscxmlcompiler.h +++ b/qt6/scxml/gen_qscxmlcompiler.h @@ -43,12 +43,8 @@ struct miqt_array /* of QScxmlError* */ QScxmlCompiler_errors(const QScxmlCompi void QScxmlCompiler_delete(QScxmlCompiler* self); QScxmlCompiler__Loader* QScxmlCompiler__Loader_new(); -struct miqt_string QScxmlCompiler__Loader_load(QScxmlCompiler__Loader* self, struct miqt_string name, struct miqt_string baseDir, struct miqt_array /* of struct miqt_string */ errors); void QScxmlCompiler__Loader_operatorAssign(QScxmlCompiler__Loader* self, QScxmlCompiler__Loader* param1); -bool QScxmlCompiler__Loader_override_virtual_load(void* self, intptr_t slot); -struct miqt_string QScxmlCompiler__Loader_virtualbase_load(void* self, struct miqt_string name, struct miqt_string baseDir, struct miqt_array /* of struct miqt_string */ errors); - void QScxmlCompiler__Loader_delete(QScxmlCompiler__Loader* self); #ifdef __cplusplus From 17a8d4a58a8391334c75530a5ace5be265e095bd Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sat, 31 Jan 2026 13:20:11 -0500 Subject: [PATCH 10/12] config-libraries.go: Remove SCXML due to current instability and clean up State Machine --- cmd/genbindings/config-libraries.go | 26 ++------------------------ 1 file changed, 2 insertions(+), 24 deletions(-) diff --git a/cmd/genbindings/config-libraries.go b/cmd/genbindings/config-libraries.go index 90f0005d8..40a70d85a 100644 --- a/cmd/genbindings/config-libraries.go +++ b/cmd/genbindings/config-libraries.go @@ -1,7 +1,6 @@ package main import ( - "fmt" "path/filepath" "strings" ) @@ -604,7 +603,7 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) { ClangMatchSameHeaderDefinitionOnly, ) - // Qt 6 QStateMachine + // Qt 6 State Machine // Depends on QtCore and QtQml generate( "qt6/statemachine", @@ -614,28 +613,7 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) { }, AllowAllHeaders, clangBin, - fmt.Sprintf("--std=c++17 %s %s", - pkgConfigCflags("Qt6StateMachine"), - pkgConfigCflags("Qt6StateMachineQml"), - ), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 SCXML - // Depends on QtCore and QtQml - generate( - "qt6/scxml", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtScxml", - "/usr/include/x86_64-linux-gnu/qt6/QtScxmlQml", - }, - AllowAllHeaders, - clangBin, - fmt.Sprintf("--std=c++17 %s %s", - pkgConfigCflags("Qt6Scxml"), - pkgConfigCflags("Qt6ScxmlQml"), - ), + "--std=c++17 "+pkgConfigCflags("Qt6StateMachineQml"), outDir, ClangMatchSameHeaderDefinitionOnly, ) From 3dddd16db7c6fa3ff45b6105f1df6b3198b2ccb7 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sat, 31 Jan 2026 13:20:46 -0500 Subject: [PATCH 11/12] config-allowlist.go: Clean up block --- cmd/genbindings/config-allowlist.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/cmd/genbindings/config-allowlist.go b/cmd/genbindings/config-allowlist.go index faed9681a..5d0824ed8 100644 --- a/cmd/genbindings/config-allowlist.go +++ b/cmd/genbindings/config-allowlist.go @@ -421,10 +421,6 @@ func AllowMethod(className string, mm CppMethod) error { return ErrTooComplex // Callbacks that the attached object types must provide to QML } - if className == "QScxmlCompiler::Loader" && mm.MethodName == "load" { - return ErrTooComplex // A pure virtual method that takes a pointer to QStringList as a parameter type - } - // Skip functions that return ints-by-reference since the ergonomics don't // go through the binding if mm.ReturnType.IntType() && mm.ReturnType.ByRef { From 85476d97fa008df129bcb556b4828572134310fc Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sat, 31 Jan 2026 13:21:33 -0500 Subject: [PATCH 12/12] qt: Rebuild (Remove Qt SCXML) --- qt6/scxml/cflags.go | 6 - qt6/scxml/gen_qscxmlcompiler.cpp | 81 - qt6/scxml/gen_qscxmlcompiler.go | 162 -- qt6/scxml/gen_qscxmlcompiler.h | 54 - qt6/scxml/gen_qscxmlcppdatamodel.cpp | 857 ---------- qt6/scxml/gen_qscxmlcppdatamodel.go | 835 ---------- qt6/scxml/gen_qscxmlcppdatamodel.h | 116 -- qt6/scxml/gen_qscxmldatamodel.cpp | 877 ----------- qt6/scxml/gen_qscxmldatamodel.go | 871 ----------- qt6/scxml/gen_qscxmldatamodel.h | 131 -- qt6/scxml/gen_qscxmlerror.cpp | 82 - qt6/scxml/gen_qscxmlerror.go | 123 -- qt6/scxml/gen_qscxmlerror.h | 40 - qt6/scxml/gen_qscxmlevent.cpp | 172 -- qt6/scxml/gen_qscxmlevent.go | 216 --- qt6/scxml/gen_qscxmlevent.h | 56 - qt6/scxml/gen_qscxmlexecutablecontent.cpp | 206 --- qt6/scxml/gen_qscxmlexecutablecontent.go | 405 ----- qt6/scxml/gen_qscxmlexecutablecontent.h | 108 -- qt6/scxml/gen_qscxmlinvokableservice.cpp | 1732 --------------------- qt6/scxml/gen_qscxmlinvokableservice.go | 1705 -------------------- qt6/scxml/gen_qscxmlinvokableservice.h | 209 --- qt6/scxml/gen_qscxmlnulldatamodel.cpp | 901 ----------- qt6/scxml/gen_qscxmlnulldatamodel.go | 872 ----------- qt6/scxml/gen_qscxmlnulldatamodel.h | 118 -- qt6/scxml/gen_qscxmlstatemachine.cpp | 535 ------- qt6/scxml/gen_qscxmlstatemachine.go | 656 -------- qt6/scxml/gen_qscxmlstatemachine.h | 124 -- qt6/scxml/gen_qscxmltabledata.cpp | 85 - qt6/scxml/gen_qscxmltabledata.go | 116 -- qt6/scxml/gen_qscxmltabledata.h | 61 - 31 files changed, 12512 deletions(-) delete mode 100644 qt6/scxml/cflags.go delete mode 100644 qt6/scxml/gen_qscxmlcompiler.cpp delete mode 100644 qt6/scxml/gen_qscxmlcompiler.go delete mode 100644 qt6/scxml/gen_qscxmlcompiler.h delete mode 100644 qt6/scxml/gen_qscxmlcppdatamodel.cpp delete mode 100644 qt6/scxml/gen_qscxmlcppdatamodel.go delete mode 100644 qt6/scxml/gen_qscxmlcppdatamodel.h delete mode 100644 qt6/scxml/gen_qscxmldatamodel.cpp delete mode 100644 qt6/scxml/gen_qscxmldatamodel.go delete mode 100644 qt6/scxml/gen_qscxmldatamodel.h delete mode 100644 qt6/scxml/gen_qscxmlerror.cpp delete mode 100644 qt6/scxml/gen_qscxmlerror.go delete mode 100644 qt6/scxml/gen_qscxmlerror.h delete mode 100644 qt6/scxml/gen_qscxmlevent.cpp delete mode 100644 qt6/scxml/gen_qscxmlevent.go delete mode 100644 qt6/scxml/gen_qscxmlevent.h delete mode 100644 qt6/scxml/gen_qscxmlexecutablecontent.cpp delete mode 100644 qt6/scxml/gen_qscxmlexecutablecontent.go delete mode 100644 qt6/scxml/gen_qscxmlexecutablecontent.h delete mode 100644 qt6/scxml/gen_qscxmlinvokableservice.cpp delete mode 100644 qt6/scxml/gen_qscxmlinvokableservice.go delete mode 100644 qt6/scxml/gen_qscxmlinvokableservice.h delete mode 100644 qt6/scxml/gen_qscxmlnulldatamodel.cpp delete mode 100644 qt6/scxml/gen_qscxmlnulldatamodel.go delete mode 100644 qt6/scxml/gen_qscxmlnulldatamodel.h delete mode 100644 qt6/scxml/gen_qscxmlstatemachine.cpp delete mode 100644 qt6/scxml/gen_qscxmlstatemachine.go delete mode 100644 qt6/scxml/gen_qscxmlstatemachine.h delete mode 100644 qt6/scxml/gen_qscxmltabledata.cpp delete mode 100644 qt6/scxml/gen_qscxmltabledata.go delete mode 100644 qt6/scxml/gen_qscxmltabledata.h diff --git a/qt6/scxml/cflags.go b/qt6/scxml/cflags.go deleted file mode 100644 index 256f6c91b..000000000 --- a/qt6/scxml/cflags.go +++ /dev/null @@ -1,6 +0,0 @@ -package scxml - -/* -#cgo pkg-config: Qt6Scxml Qt6ScxmlQml -*/ -import "C" diff --git a/qt6/scxml/gen_qscxmlcompiler.cpp b/qt6/scxml/gen_qscxmlcompiler.cpp deleted file mode 100644 index 5da0979f6..000000000 --- a/qt6/scxml/gen_qscxmlcompiler.cpp +++ /dev/null @@ -1,81 +0,0 @@ -#include -#include -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlCompiler__Loader -#include -#include -#include -#include -#include -#include -#include -#include "gen_qscxmlcompiler.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __cplusplus -} /* extern C */ -#endif - -QScxmlCompiler* QScxmlCompiler_new(QXmlStreamReader* xmlReader) { - return new (std::nothrow) QScxmlCompiler(xmlReader); -} - -struct miqt_string QScxmlCompiler_fileName(const QScxmlCompiler* self) { - QString _ret = self->fileName(); - // 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 QScxmlCompiler_setFileName(QScxmlCompiler* self, struct miqt_string fileName) { - QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); - self->setFileName(fileName_QString); -} - -QScxmlCompiler__Loader* QScxmlCompiler_loader(const QScxmlCompiler* self) { - return self->loader(); -} - -void QScxmlCompiler_setLoader(QScxmlCompiler* self, QScxmlCompiler__Loader* newLoader) { - self->setLoader(newLoader); -} - -QScxmlStateMachine* QScxmlCompiler_compile(QScxmlCompiler* self) { - return self->compile(); -} - -struct miqt_array /* of QScxmlError* */ QScxmlCompiler_errors(const QScxmlCompiler* self) { - QList _ret = self->errors(); - // Convert QList<> from C++ memory to manually-managed C memory - QScxmlError** _arr = static_cast(malloc(sizeof(QScxmlError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { - _arr[i] = new QScxmlError(_ret[i]); - } - struct miqt_array _out; - _out.len = _ret.length(); - _out.data = static_cast(_arr); - return _out; -} - -void QScxmlCompiler_delete(QScxmlCompiler* self) { - delete self; -} - -QScxmlCompiler__Loader* QScxmlCompiler__Loader_new() { - return new (std::nothrow) QScxmlCompiler::Loader(); -} - -void QScxmlCompiler__Loader_operatorAssign(QScxmlCompiler__Loader* self, QScxmlCompiler__Loader* param1) { - self->operator=(*param1); -} - -void QScxmlCompiler__Loader_delete(QScxmlCompiler__Loader* self) { - delete self; -} - diff --git a/qt6/scxml/gen_qscxmlcompiler.go b/qt6/scxml/gen_qscxmlcompiler.go deleted file mode 100644 index 4734608bb..000000000 --- a/qt6/scxml/gen_qscxmlcompiler.go +++ /dev/null @@ -1,162 +0,0 @@ -package scxml - -/* - -#include "gen_qscxmlcompiler.h" -#include - -*/ -import "C" - -import ( - "github.com/mappu/miqt/qt6" - "runtime" - "unsafe" -) - -type QScxmlCompiler struct { - h *C.QScxmlCompiler -} - -func (this *QScxmlCompiler) cPointer() *C.QScxmlCompiler { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlCompiler) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlCompiler constructs the type using only CGO pointers. -func newQScxmlCompiler(h *C.QScxmlCompiler) *QScxmlCompiler { - if h == nil { - return nil - } - - return &QScxmlCompiler{h: h} -} - -// UnsafeNewQScxmlCompiler constructs the type using only unsafe pointers. -func UnsafeNewQScxmlCompiler(h unsafe.Pointer) *QScxmlCompiler { - return newQScxmlCompiler((*C.QScxmlCompiler)(h)) -} - -// NewQScxmlCompiler constructs a new QScxmlCompiler object. -func NewQScxmlCompiler(xmlReader *qt6.QXmlStreamReader) *QScxmlCompiler { - - return newQScxmlCompiler(C.QScxmlCompiler_new((*C.QXmlStreamReader)(xmlReader.UnsafePointer()))) -} - -func (this *QScxmlCompiler) FileName() string { - var _ms C.struct_miqt_string = C.QScxmlCompiler_fileName(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlCompiler) SetFileName(fileName string) { - 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)) - C.QScxmlCompiler_setFileName(this.h, fileName_ms) -} - -func (this *QScxmlCompiler) Loader() *QScxmlCompiler__Loader { - return newQScxmlCompiler__Loader(C.QScxmlCompiler_loader(this.h)) -} - -func (this *QScxmlCompiler) SetLoader(newLoader *QScxmlCompiler__Loader) { - C.QScxmlCompiler_setLoader(this.h, newLoader.cPointer()) -} - -func (this *QScxmlCompiler) Compile() *QScxmlStateMachine { - return newQScxmlStateMachine(C.QScxmlCompiler_compile(this.h)) -} - -func (this *QScxmlCompiler) Errors() []QScxmlError { - var _ma C.struct_miqt_array = C.QScxmlCompiler_errors(this.h) - _ret := make([]QScxmlError, int(_ma.len)) - _outCast := (*[0xffff]*C.QScxmlError)(unsafe.Pointer(_ma.data)) // hey ya - for i := 0; i < int(_ma.len); i++ { - _lv_goptr := newQScxmlError(_outCast[i]) - _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - _ret[i] = *_lv_goptr - } - return _ret -} - -// Delete this object from C++ memory. -func (this *QScxmlCompiler) Delete() { - C.QScxmlCompiler_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 *QScxmlCompiler) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlCompiler) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} - -type QScxmlCompiler__Loader struct { - h *C.QScxmlCompiler__Loader -} - -func (this *QScxmlCompiler__Loader) cPointer() *C.QScxmlCompiler__Loader { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlCompiler__Loader) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlCompiler__Loader constructs the type using only CGO pointers. -func newQScxmlCompiler__Loader(h *C.QScxmlCompiler__Loader) *QScxmlCompiler__Loader { - if h == nil { - return nil - } - - return &QScxmlCompiler__Loader{h: h} -} - -// UnsafeNewQScxmlCompiler__Loader constructs the type using only unsafe pointers. -func UnsafeNewQScxmlCompiler__Loader(h unsafe.Pointer) *QScxmlCompiler__Loader { - return newQScxmlCompiler__Loader((*C.QScxmlCompiler__Loader)(h)) -} - -// NewQScxmlCompiler__Loader constructs a new QScxmlCompiler::Loader object. -func NewQScxmlCompiler__Loader() *QScxmlCompiler__Loader { - - return newQScxmlCompiler__Loader(C.QScxmlCompiler__Loader_new()) -} - -func (this *QScxmlCompiler__Loader) OperatorAssign(param1 *QScxmlCompiler__Loader) { - C.QScxmlCompiler__Loader_operatorAssign(this.h, param1.cPointer()) -} - -// Delete this object from C++ memory. -func (this *QScxmlCompiler__Loader) Delete() { - C.QScxmlCompiler__Loader_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 *QScxmlCompiler__Loader) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlCompiler__Loader) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} diff --git a/qt6/scxml/gen_qscxmlcompiler.h b/qt6/scxml/gen_qscxmlcompiler.h deleted file mode 100644 index 84b13490c..000000000 --- a/qt6/scxml/gen_qscxmlcompiler.h +++ /dev/null @@ -1,54 +0,0 @@ -#pragma once -#ifndef MIQT_QT6_SCXML_GEN_QSCXMLCOMPILER_H -#define MIQT_QT6_SCXML_GEN_QSCXMLCOMPILER_H - -#include -#include -#include - -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - -#include "../../libmiqt/libmiqt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __cplusplus -class QScxmlCompiler; -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlCompiler__Loader) -typedef QScxmlCompiler::Loader QScxmlCompiler__Loader; -#else -class QScxmlCompiler__Loader; -#endif -class QScxmlError; -class QScxmlStateMachine; -class QXmlStreamReader; -#else -typedef struct QScxmlCompiler QScxmlCompiler; -typedef struct QScxmlCompiler__Loader QScxmlCompiler__Loader; -typedef struct QScxmlError QScxmlError; -typedef struct QScxmlStateMachine QScxmlStateMachine; -typedef struct QXmlStreamReader QXmlStreamReader; -#endif - -QScxmlCompiler* QScxmlCompiler_new(QXmlStreamReader* xmlReader); -struct miqt_string QScxmlCompiler_fileName(const QScxmlCompiler* self); -void QScxmlCompiler_setFileName(QScxmlCompiler* self, struct miqt_string fileName); -QScxmlCompiler__Loader* QScxmlCompiler_loader(const QScxmlCompiler* self); -void QScxmlCompiler_setLoader(QScxmlCompiler* self, QScxmlCompiler__Loader* newLoader); -QScxmlStateMachine* QScxmlCompiler_compile(QScxmlCompiler* self); -struct miqt_array /* of QScxmlError* */ QScxmlCompiler_errors(const QScxmlCompiler* self); - -void QScxmlCompiler_delete(QScxmlCompiler* self); - -QScxmlCompiler__Loader* QScxmlCompiler__Loader_new(); -void QScxmlCompiler__Loader_operatorAssign(QScxmlCompiler__Loader* self, QScxmlCompiler__Loader* param1); - -void QScxmlCompiler__Loader_delete(QScxmlCompiler__Loader* self); - -#ifdef __cplusplus -} /* extern C */ -#endif - -#endif diff --git a/qt6/scxml/gen_qscxmlcppdatamodel.cpp b/qt6/scxml/gen_qscxmlcppdatamodel.cpp deleted file mode 100644 index 0dade1dbf..000000000 --- a/qt6/scxml/gen_qscxmlcppdatamodel.cpp +++ /dev/null @@ -1,857 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlDataModel__ForeachLoopBody -#include -#include -#include -#include -#include -#include -#include -#include "gen_qscxmlcppdatamodel.h" - -#ifdef __cplusplus -extern "C" { -#endif - -bool miqt_exec_callback_QScxmlCppDataModel_setup(QScxmlCppDataModel*, intptr_t, struct miqt_map /* of struct miqt_string to QVariant* */ ); -void miqt_exec_callback_QScxmlCppDataModel_evaluateAssignment(QScxmlCppDataModel*, intptr_t, int, bool*); -void miqt_exec_callback_QScxmlCppDataModel_evaluateInitialization(QScxmlCppDataModel*, intptr_t, int, bool*); -void miqt_exec_callback_QScxmlCppDataModel_evaluateForeach(QScxmlCppDataModel*, intptr_t, int, bool*, QScxmlDataModel__ForeachLoopBody*); -void miqt_exec_callback_QScxmlCppDataModel_setScxmlEvent(QScxmlCppDataModel*, intptr_t, QScxmlEvent*); -QVariant* miqt_exec_callback_QScxmlCppDataModel_scxmlProperty(const QScxmlCppDataModel*, intptr_t, struct miqt_string); -bool miqt_exec_callback_QScxmlCppDataModel_hasScxmlProperty(const QScxmlCppDataModel*, intptr_t, struct miqt_string); -bool miqt_exec_callback_QScxmlCppDataModel_setScxmlProperty(QScxmlCppDataModel*, intptr_t, struct miqt_string, QVariant*, struct miqt_string); -struct miqt_string miqt_exec_callback_QScxmlCppDataModel_evaluateToString(QScxmlCppDataModel*, intptr_t, int, bool*); -bool miqt_exec_callback_QScxmlCppDataModel_evaluateToBool(QScxmlCppDataModel*, intptr_t, int, bool*); -QVariant* miqt_exec_callback_QScxmlCppDataModel_evaluateToVariant(QScxmlCppDataModel*, intptr_t, int, bool*); -void miqt_exec_callback_QScxmlCppDataModel_evaluateToVoid(QScxmlCppDataModel*, intptr_t, int, bool*); -bool miqt_exec_callback_QScxmlCppDataModel_event(QScxmlCppDataModel*, intptr_t, QEvent*); -bool miqt_exec_callback_QScxmlCppDataModel_eventFilter(QScxmlCppDataModel*, intptr_t, QObject*, QEvent*); -void miqt_exec_callback_QScxmlCppDataModel_timerEvent(QScxmlCppDataModel*, intptr_t, QTimerEvent*); -void miqt_exec_callback_QScxmlCppDataModel_childEvent(QScxmlCppDataModel*, intptr_t, QChildEvent*); -void miqt_exec_callback_QScxmlCppDataModel_customEvent(QScxmlCppDataModel*, intptr_t, QEvent*); -void miqt_exec_callback_QScxmlCppDataModel_connectNotify(QScxmlCppDataModel*, intptr_t, QMetaMethod*); -void miqt_exec_callback_QScxmlCppDataModel_disconnectNotify(QScxmlCppDataModel*, intptr_t, QMetaMethod*); -#ifdef __cplusplus -} /* extern C */ -#endif - -class MiqtVirtualQScxmlCppDataModel final : public QScxmlCppDataModel { -public: - - MiqtVirtualQScxmlCppDataModel(): QScxmlCppDataModel() {} - MiqtVirtualQScxmlCppDataModel(QObject* parent): QScxmlCppDataModel(parent) {} - - virtual ~MiqtVirtualQScxmlCppDataModel() override = default; - - // cgo.Handle value for overwritten implementation - intptr_t handle__setup = 0; - - // Subclass to allow providing a Go implementation - virtual bool setup(const QVariantMap& initialDataValues) override { - if (handle__setup == 0) { - return QScxmlCppDataModel::setup(initialDataValues); - } - - const QVariantMap& initialDataValues_ret = initialDataValues; - // Convert QMap<> from C++ memory to manually-managed C memory - struct miqt_string* initialDataValues_karr = static_cast(malloc(sizeof(struct miqt_string) * initialDataValues_ret.size())); - QVariant** initialDataValues_varr = static_cast(malloc(sizeof(QVariant*) * initialDataValues_ret.size())); - int initialDataValues_ctr = 0; - for (auto initialDataValues_itr = initialDataValues_ret.keyValueBegin(); initialDataValues_itr != initialDataValues_ret.keyValueEnd(); ++initialDataValues_itr) { - QString initialDataValues_mapkey_ret = initialDataValues_itr->first; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray initialDataValues_mapkey_b = initialDataValues_mapkey_ret.toUtf8(); - struct miqt_string initialDataValues_mapkey_ms; - initialDataValues_mapkey_ms.len = initialDataValues_mapkey_b.length(); - initialDataValues_mapkey_ms.data = static_cast(malloc(initialDataValues_mapkey_ms.len)); - memcpy(initialDataValues_mapkey_ms.data, initialDataValues_mapkey_b.data(), initialDataValues_mapkey_ms.len); - initialDataValues_karr[initialDataValues_ctr] = initialDataValues_mapkey_ms; - initialDataValues_varr[initialDataValues_ctr] = new QVariant(initialDataValues_itr->second); - initialDataValues_ctr++; - } - struct miqt_map initialDataValues_out; - initialDataValues_out.len = initialDataValues_ret.size(); - initialDataValues_out.keys = static_cast(initialDataValues_karr); - initialDataValues_out.values = static_cast(initialDataValues_varr); - struct miqt_map /* of struct miqt_string to QVariant* */ sigval1 = initialDataValues_out; - bool callback_return_value = miqt_exec_callback_QScxmlCppDataModel_setup(this, handle__setup, sigval1); - return callback_return_value; - } - - friend bool QScxmlCppDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateAssignment = 0; - - // Subclass to allow providing a Go implementation - virtual void evaluateAssignment(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateAssignment == 0) { - QScxmlCppDataModel::evaluateAssignment(id, ok); - return; - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - miqt_exec_callback_QScxmlCppDataModel_evaluateAssignment(this, handle__evaluateAssignment, sigval1, sigval2); - - } - - friend void QScxmlCppDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok); - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateInitialization = 0; - - // Subclass to allow providing a Go implementation - virtual void evaluateInitialization(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateInitialization == 0) { - QScxmlCppDataModel::evaluateInitialization(id, ok); - return; - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - miqt_exec_callback_QScxmlCppDataModel_evaluateInitialization(this, handle__evaluateInitialization, sigval1, sigval2); - - } - - friend void QScxmlCppDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok); - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateForeach = 0; - - // Subclass to allow providing a Go implementation - virtual void evaluateForeach(QScxmlExecutableContent::EvaluatorId id, bool* ok, QScxmlDataModel::ForeachLoopBody* body) override { - if (handle__evaluateForeach == 0) { - QScxmlCppDataModel::evaluateForeach(id, ok, body); - return; - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - QScxmlDataModel__ForeachLoopBody* sigval3 = body; - miqt_exec_callback_QScxmlCppDataModel_evaluateForeach(this, handle__evaluateForeach, sigval1, sigval2, sigval3); - - } - - friend void QScxmlCppDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); - - // cgo.Handle value for overwritten implementation - intptr_t handle__setScxmlEvent = 0; - - // Subclass to allow providing a Go implementation - virtual void setScxmlEvent(const QScxmlEvent& scxmlEvent) override { - if (handle__setScxmlEvent == 0) { - QScxmlCppDataModel::setScxmlEvent(scxmlEvent); - return; - } - - const QScxmlEvent& scxmlEvent_ret = scxmlEvent; - // Cast returned reference into pointer - QScxmlEvent* sigval1 = const_cast(&scxmlEvent_ret); - miqt_exec_callback_QScxmlCppDataModel_setScxmlEvent(this, handle__setScxmlEvent, sigval1); - - } - - friend void QScxmlCppDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* scxmlEvent); - - // cgo.Handle value for overwritten implementation - intptr_t handle__scxmlProperty = 0; - - // Subclass to allow providing a Go implementation - virtual QVariant scxmlProperty(const QString& name) const override { - if (handle__scxmlProperty == 0) { - return QScxmlCppDataModel::scxmlProperty(name); - } - - const QString name_ret = name; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray name_b = name_ret.toUtf8(); - struct miqt_string name_ms; - name_ms.len = name_b.length(); - name_ms.data = static_cast(malloc(name_ms.len)); - memcpy(name_ms.data, name_b.data(), name_ms.len); - struct miqt_string sigval1 = name_ms; - QVariant* callback_return_value = miqt_exec_callback_QScxmlCppDataModel_scxmlProperty(this, handle__scxmlProperty, sigval1); - return *callback_return_value; - } - - friend QVariant* QScxmlCppDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name); - - // cgo.Handle value for overwritten implementation - intptr_t handle__hasScxmlProperty = 0; - - // Subclass to allow providing a Go implementation - virtual bool hasScxmlProperty(const QString& name) const override { - if (handle__hasScxmlProperty == 0) { - return QScxmlCppDataModel::hasScxmlProperty(name); - } - - const QString name_ret = name; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray name_b = name_ret.toUtf8(); - struct miqt_string name_ms; - name_ms.len = name_b.length(); - name_ms.data = static_cast(malloc(name_ms.len)); - memcpy(name_ms.data, name_b.data(), name_ms.len); - struct miqt_string sigval1 = name_ms; - bool callback_return_value = miqt_exec_callback_QScxmlCppDataModel_hasScxmlProperty(this, handle__hasScxmlProperty, sigval1); - return callback_return_value; - } - - friend bool QScxmlCppDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name); - - // cgo.Handle value for overwritten implementation - intptr_t handle__setScxmlProperty = 0; - - // Subclass to allow providing a Go implementation - virtual bool setScxmlProperty(const QString& name, const QVariant& value, const QString& context) override { - if (handle__setScxmlProperty == 0) { - return QScxmlCppDataModel::setScxmlProperty(name, value, context); - } - - const QString name_ret = name; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray name_b = name_ret.toUtf8(); - struct miqt_string name_ms; - name_ms.len = name_b.length(); - name_ms.data = static_cast(malloc(name_ms.len)); - memcpy(name_ms.data, name_b.data(), name_ms.len); - struct miqt_string sigval1 = name_ms; - const QVariant& value_ret = value; - // Cast returned reference into pointer - QVariant* sigval2 = const_cast(&value_ret); - const QString context_ret = context; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray context_b = context_ret.toUtf8(); - struct miqt_string context_ms; - context_ms.len = context_b.length(); - context_ms.data = static_cast(malloc(context_ms.len)); - memcpy(context_ms.data, context_b.data(), context_ms.len); - struct miqt_string sigval3 = context_ms; - bool callback_return_value = miqt_exec_callback_QScxmlCppDataModel_setScxmlProperty(this, handle__setScxmlProperty, sigval1, sigval2, sigval3); - return callback_return_value; - } - - friend bool QScxmlCppDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context); - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateToString = 0; - - // Subclass to allow providing a Go implementation - virtual QString evaluateToString(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateToString == 0) { - return QString(); // Pure virtual, there is no base we can call - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - struct miqt_string callback_return_value = miqt_exec_callback_QScxmlCppDataModel_evaluateToString(this, handle__evaluateToString, sigval1, sigval2); - QString callback_return_value_QString = QString::fromUtf8(callback_return_value.data, callback_return_value.len); - return callback_return_value_QString; - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateToBool = 0; - - // Subclass to allow providing a Go implementation - virtual bool evaluateToBool(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateToBool == 0) { - return false; // Pure virtual, there is no base we can call - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - bool callback_return_value = miqt_exec_callback_QScxmlCppDataModel_evaluateToBool(this, handle__evaluateToBool, sigval1, sigval2); - return callback_return_value; - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateToVariant = 0; - - // Subclass to allow providing a Go implementation - virtual QVariant evaluateToVariant(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateToVariant == 0) { - return QVariant(); // Pure virtual, there is no base we can call - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - QVariant* callback_return_value = miqt_exec_callback_QScxmlCppDataModel_evaluateToVariant(this, handle__evaluateToVariant, sigval1, sigval2); - return *callback_return_value; - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateToVoid = 0; - - // Subclass to allow providing a Go implementation - virtual void evaluateToVoid(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateToVoid == 0) { - return; // Pure virtual, there is no base we can call - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - miqt_exec_callback_QScxmlCppDataModel_evaluateToVoid(this, handle__evaluateToVoid, sigval1, sigval2); - - } - - // 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 QScxmlCppDataModel::event(event); - } - - QEvent* sigval1 = event; - bool callback_return_value = miqt_exec_callback_QScxmlCppDataModel_event(this, handle__event, sigval1); - return callback_return_value; - } - - friend bool QScxmlCppDataModel_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 QScxmlCppDataModel::eventFilter(watched, event); - } - - QObject* sigval1 = watched; - QEvent* sigval2 = event; - bool callback_return_value = miqt_exec_callback_QScxmlCppDataModel_eventFilter(this, handle__eventFilter, sigval1, sigval2); - return callback_return_value; - } - - friend bool QScxmlCppDataModel_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) { - QScxmlCppDataModel::timerEvent(event); - return; - } - - QTimerEvent* sigval1 = event; - miqt_exec_callback_QScxmlCppDataModel_timerEvent(this, handle__timerEvent, sigval1); - - } - - friend void QScxmlCppDataModel_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) { - QScxmlCppDataModel::childEvent(event); - return; - } - - QChildEvent* sigval1 = event; - miqt_exec_callback_QScxmlCppDataModel_childEvent(this, handle__childEvent, sigval1); - - } - - friend void QScxmlCppDataModel_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) { - QScxmlCppDataModel::customEvent(event); - return; - } - - QEvent* sigval1 = event; - miqt_exec_callback_QScxmlCppDataModel_customEvent(this, handle__customEvent, sigval1); - - } - - friend void QScxmlCppDataModel_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) { - QScxmlCppDataModel::connectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlCppDataModel_connectNotify(this, handle__connectNotify, sigval1); - - } - - friend void QScxmlCppDataModel_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) { - QScxmlCppDataModel::disconnectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlCppDataModel_disconnectNotify(this, handle__disconnectNotify, sigval1); - - } - - friend void QScxmlCppDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - - // Wrappers to allow calling protected methods: - friend QObject* QScxmlCppDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlCppDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlCppDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); - friend bool QScxmlCppDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); -}; - -QScxmlCppDataModel* QScxmlCppDataModel_new() { - return new (std::nothrow) MiqtVirtualQScxmlCppDataModel(); -} - -QScxmlCppDataModel* QScxmlCppDataModel_new2(QObject* parent) { - return new (std::nothrow) MiqtVirtualQScxmlCppDataModel(parent); -} - -void QScxmlCppDataModel_virtbase(QScxmlCppDataModel* src, QScxmlDataModel** outptr_QScxmlDataModel) { - *outptr_QScxmlDataModel = static_cast(src); -} - -QMetaObject* QScxmlCppDataModel_metaObject(const QScxmlCppDataModel* self) { - return (QMetaObject*) self->metaObject(); -} - -void* QScxmlCppDataModel_metacast(QScxmlCppDataModel* self, const char* param1) { - return self->qt_metacast(param1); -} - -struct miqt_string QScxmlCppDataModel_tr(const char* s) { - QString _ret = QScxmlCppDataModel::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; -} - -bool QScxmlCppDataModel_setup(QScxmlCppDataModel* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues) { - QVariantMap initialDataValues_QMap; - struct miqt_string* initialDataValues_karr = static_cast(initialDataValues.keys); - QVariant** initialDataValues_varr = static_cast(initialDataValues.values); - for(size_t i = 0; i < initialDataValues.len; ++i) { - QString initialDataValues_karr_i_QString = QString::fromUtf8(initialDataValues_karr[i].data, initialDataValues_karr[i].len); - initialDataValues_QMap[initialDataValues_karr_i_QString] = *(initialDataValues_varr[i]); - } - return self->setup(initialDataValues_QMap); -} - -void QScxmlCppDataModel_evaluateAssignment(QScxmlCppDataModel* self, int id, bool* ok) { - self->evaluateAssignment(static_cast(id), ok); -} - -void QScxmlCppDataModel_evaluateInitialization(QScxmlCppDataModel* self, int id, bool* ok) { - self->evaluateInitialization(static_cast(id), ok); -} - -void QScxmlCppDataModel_evaluateForeach(QScxmlCppDataModel* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body) { - self->evaluateForeach(static_cast(id), ok, body); -} - -void QScxmlCppDataModel_setScxmlEvent(QScxmlCppDataModel* self, QScxmlEvent* scxmlEvent) { - self->setScxmlEvent(*scxmlEvent); -} - -QScxmlEvent* QScxmlCppDataModel_scxmlEvent(const QScxmlCppDataModel* self) { - const QScxmlEvent& _ret = self->scxmlEvent(); - // Cast returned reference into pointer - return const_cast(&_ret); -} - -QVariant* QScxmlCppDataModel_scxmlProperty(const QScxmlCppDataModel* self, struct miqt_string name) { - QString name_QString = QString::fromUtf8(name.data, name.len); - return new QVariant(self->scxmlProperty(name_QString)); -} - -bool QScxmlCppDataModel_hasScxmlProperty(const QScxmlCppDataModel* self, struct miqt_string name) { - QString name_QString = QString::fromUtf8(name.data, name.len); - return self->hasScxmlProperty(name_QString); -} - -bool QScxmlCppDataModel_setScxmlProperty(QScxmlCppDataModel* self, struct miqt_string name, QVariant* value, struct miqt_string context) { - QString name_QString = QString::fromUtf8(name.data, name.len); - QString context_QString = QString::fromUtf8(context.data, context.len); - return self->setScxmlProperty(name_QString, *value, context_QString); -} - -bool QScxmlCppDataModel_inState(const QScxmlCppDataModel* self, struct miqt_string stateName) { - QString stateName_QString = QString::fromUtf8(stateName.data, stateName.len); - return self->inState(stateName_QString); -} - -struct miqt_string QScxmlCppDataModel_tr2(const char* s, const char* c) { - QString _ret = QScxmlCppDataModel::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 QScxmlCppDataModel_tr3(const char* s, const char* c, int n) { - QString _ret = QScxmlCppDataModel::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 QScxmlCppDataModel_override_virtual_setup(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__setup = slot; - return true; -} - -bool QScxmlCppDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues) { - QVariantMap initialDataValues_QMap; - struct miqt_string* initialDataValues_karr = static_cast(initialDataValues.keys); - QVariant** initialDataValues_varr = static_cast(initialDataValues.values); - for(size_t i = 0; i < initialDataValues.len; ++i) { - QString initialDataValues_karr_i_QString = QString::fromUtf8(initialDataValues_karr[i].data, initialDataValues_karr[i].len); - initialDataValues_QMap[initialDataValues_karr_i_QString] = *(initialDataValues_varr[i]); - } - return static_cast(self)->QScxmlCppDataModel::setup(initialDataValues_QMap); -} - -bool QScxmlCppDataModel_override_virtual_evaluateAssignment(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateAssignment = slot; - return true; -} - -void QScxmlCppDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok) { - static_cast(self)->QScxmlCppDataModel::evaluateAssignment(static_cast(id), ok); -} - -bool QScxmlCppDataModel_override_virtual_evaluateInitialization(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateInitialization = slot; - return true; -} - -void QScxmlCppDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok) { - static_cast(self)->QScxmlCppDataModel::evaluateInitialization(static_cast(id), ok); -} - -bool QScxmlCppDataModel_override_virtual_evaluateForeach(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateForeach = slot; - return true; -} - -void QScxmlCppDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body) { - static_cast(self)->QScxmlCppDataModel::evaluateForeach(static_cast(id), ok, body); -} - -bool QScxmlCppDataModel_override_virtual_setScxmlEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__setScxmlEvent = slot; - return true; -} - -void QScxmlCppDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* scxmlEvent) { - static_cast(self)->QScxmlCppDataModel::setScxmlEvent(*scxmlEvent); -} - -bool QScxmlCppDataModel_override_virtual_scxmlProperty(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__scxmlProperty = slot; - return true; -} - -QVariant* QScxmlCppDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name) { - QString name_QString = QString::fromUtf8(name.data, name.len); - return new QVariant(static_cast(self)->QScxmlCppDataModel::scxmlProperty(name_QString)); -} - -bool QScxmlCppDataModel_override_virtual_hasScxmlProperty(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__hasScxmlProperty = slot; - return true; -} - -bool QScxmlCppDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name) { - QString name_QString = QString::fromUtf8(name.data, name.len); - return static_cast(self)->QScxmlCppDataModel::hasScxmlProperty(name_QString); -} - -bool QScxmlCppDataModel_override_virtual_setScxmlProperty(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__setScxmlProperty = slot; - return true; -} - -bool QScxmlCppDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context) { - QString name_QString = QString::fromUtf8(name.data, name.len); - QString context_QString = QString::fromUtf8(context.data, context.len); - return static_cast(self)->QScxmlCppDataModel::setScxmlProperty(name_QString, *value, context_QString); -} - -bool QScxmlCppDataModel_override_virtual_evaluateToString(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateToString = slot; - return true; -} - -bool QScxmlCppDataModel_override_virtual_evaluateToBool(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateToBool = slot; - return true; -} - -bool QScxmlCppDataModel_override_virtual_evaluateToVariant(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateToVariant = slot; - return true; -} - -bool QScxmlCppDataModel_override_virtual_evaluateToVoid(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateToVoid = slot; - return true; -} - -bool QScxmlCppDataModel_override_virtual_event(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__event = slot; - return true; -} - -bool QScxmlCppDataModel_virtualbase_event(void* self, QEvent* event) { - return static_cast(self)->QScxmlCppDataModel::event(event); -} - -bool QScxmlCppDataModel_override_virtual_eventFilter(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__eventFilter = slot; - return true; -} - -bool QScxmlCppDataModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { - return static_cast(self)->QScxmlCppDataModel::eventFilter(watched, event); -} - -bool QScxmlCppDataModel_override_virtual_timerEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__timerEvent = slot; - return true; -} - -void QScxmlCppDataModel_virtualbase_timerEvent(void* self, QTimerEvent* event) { - static_cast(self)->QScxmlCppDataModel::timerEvent(event); -} - -bool QScxmlCppDataModel_override_virtual_childEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__childEvent = slot; - return true; -} - -void QScxmlCppDataModel_virtualbase_childEvent(void* self, QChildEvent* event) { - static_cast(self)->QScxmlCppDataModel::childEvent(event); -} - -bool QScxmlCppDataModel_override_virtual_customEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__customEvent = slot; - return true; -} - -void QScxmlCppDataModel_virtualbase_customEvent(void* self, QEvent* event) { - static_cast(self)->QScxmlCppDataModel::customEvent(event); -} - -bool QScxmlCppDataModel_override_virtual_connectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__connectNotify = slot; - return true; -} - -void QScxmlCppDataModel_virtualbase_connectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlCppDataModel::connectNotify(*signal); -} - -bool QScxmlCppDataModel_override_virtual_disconnectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__disconnectNotify = slot; - return true; -} - -void QScxmlCppDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlCppDataModel::disconnectNotify(*signal); -} - -QObject* QScxmlCppDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return nullptr; - } - - *_dynamic_cast_ok = true; - return self_cast->sender(); -} - -int QScxmlCppDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->senderSignalIndex(); -} - -int QScxmlCppDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->receivers(signal); -} - -bool QScxmlCppDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { - MiqtVirtualQScxmlCppDataModel* self_cast = dynamic_cast( (QScxmlCppDataModel*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return false; - } - - *_dynamic_cast_ok = true; - return self_cast->isSignalConnected(*signal); -} - -void QScxmlCppDataModel_delete(QScxmlCppDataModel* self) { - delete self; -} - diff --git a/qt6/scxml/gen_qscxmlcppdatamodel.go b/qt6/scxml/gen_qscxmlcppdatamodel.go deleted file mode 100644 index a7fda149e..000000000 --- a/qt6/scxml/gen_qscxmlcppdatamodel.go +++ /dev/null @@ -1,835 +0,0 @@ -package scxml - -/* - -#include "gen_qscxmlcppdatamodel.h" -#include - -*/ -import "C" - -import ( - "github.com/mappu/miqt/qt6" - "runtime" - "runtime/cgo" - "unsafe" -) - -type QScxmlCppDataModel struct { - h *C.QScxmlCppDataModel - *QScxmlDataModel -} - -func (this *QScxmlCppDataModel) cPointer() *C.QScxmlCppDataModel { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlCppDataModel) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlCppDataModel constructs the type using only CGO pointers. -func newQScxmlCppDataModel(h *C.QScxmlCppDataModel) *QScxmlCppDataModel { - if h == nil { - return nil - } - var outptr_QScxmlDataModel *C.QScxmlDataModel = nil - C.QScxmlCppDataModel_virtbase(h, &outptr_QScxmlDataModel) - - return &QScxmlCppDataModel{h: h, - QScxmlDataModel: newQScxmlDataModel(outptr_QScxmlDataModel)} -} - -// UnsafeNewQScxmlCppDataModel constructs the type using only unsafe pointers. -func UnsafeNewQScxmlCppDataModel(h unsafe.Pointer) *QScxmlCppDataModel { - return newQScxmlCppDataModel((*C.QScxmlCppDataModel)(h)) -} - -// NewQScxmlCppDataModel constructs a new QScxmlCppDataModel object. -func NewQScxmlCppDataModel() *QScxmlCppDataModel { - - return newQScxmlCppDataModel(C.QScxmlCppDataModel_new()) -} - -// NewQScxmlCppDataModel2 constructs a new QScxmlCppDataModel object. -func NewQScxmlCppDataModel2(parent *qt6.QObject) *QScxmlCppDataModel { - - return newQScxmlCppDataModel(C.QScxmlCppDataModel_new2((*C.QObject)(parent.UnsafePointer()))) -} - -func (this *QScxmlCppDataModel) MetaObject() *qt6.QMetaObject { - return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlCppDataModel_metaObject(this.h))) -} - -func (this *QScxmlCppDataModel) Metacast(param1 string) unsafe.Pointer { - param1_Cstring := C.CString(param1) - defer C.free(unsafe.Pointer(param1_Cstring)) - return (unsafe.Pointer)(C.QScxmlCppDataModel_metacast(this.h, param1_Cstring)) -} - -func QScxmlCppDataModel_Tr(s string) string { - s_Cstring := C.CString(s) - defer C.free(unsafe.Pointer(s_Cstring)) - var _ms C.struct_miqt_string = C.QScxmlCppDataModel_tr(s_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlCppDataModel) Setup(initialDataValues map[string]qt6.QVariant) bool { - initialDataValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialDataValues)))) - defer C.free(unsafe.Pointer(initialDataValues_Keys_CArray)) - initialDataValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialDataValues)))) - defer C.free(unsafe.Pointer(initialDataValues_Values_CArray)) - initialDataValues_ctr := 0 - for initialDataValues_k, initialDataValues_v := range initialDataValues { - initialDataValues_k_ms := C.struct_miqt_string{} - initialDataValues_k_ms.data = C.CString(initialDataValues_k) - initialDataValues_k_ms.len = C.size_t(len(initialDataValues_k)) - defer C.free(unsafe.Pointer(initialDataValues_k_ms.data)) - initialDataValues_Keys_CArray[initialDataValues_ctr] = initialDataValues_k_ms - initialDataValues_Values_CArray[initialDataValues_ctr] = (*C.QVariant)(initialDataValues_v.UnsafePointer()) - initialDataValues_ctr++ - } - initialDataValues_mm := C.struct_miqt_map{ - len: C.size_t(len(initialDataValues)), - keys: unsafe.Pointer(initialDataValues_Keys_CArray), - values: unsafe.Pointer(initialDataValues_Values_CArray), - } - return (bool)(C.QScxmlCppDataModel_setup(this.h, initialDataValues_mm)) -} - -func (this *QScxmlCppDataModel) EvaluateAssignment(id int, ok *bool) { - C.QScxmlCppDataModel_evaluateAssignment(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) -} - -func (this *QScxmlCppDataModel) EvaluateInitialization(id int, ok *bool) { - C.QScxmlCppDataModel_evaluateInitialization(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) -} - -func (this *QScxmlCppDataModel) EvaluateForeach(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody) { - C.QScxmlCppDataModel_evaluateForeach(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok)), body.cPointer()) -} - -func (this *QScxmlCppDataModel) SetScxmlEvent(scxmlEvent *QScxmlEvent) { - C.QScxmlCppDataModel_setScxmlEvent(this.h, scxmlEvent.cPointer()) -} - -func (this *QScxmlCppDataModel) ScxmlEvent() *QScxmlEvent { - return newQScxmlEvent(C.QScxmlCppDataModel_scxmlEvent(this.h)) -} - -func (this *QScxmlCppDataModel) ScxmlProperty(name string) *qt6.QVariant { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlCppDataModel_scxmlProperty(this.h, name_ms))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -func (this *QScxmlCppDataModel) HasScxmlProperty(name string) bool { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - return (bool)(C.QScxmlCppDataModel_hasScxmlProperty(this.h, name_ms)) -} - -func (this *QScxmlCppDataModel) SetScxmlProperty(name string, value *qt6.QVariant, context string) bool { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - context_ms := C.struct_miqt_string{} - context_ms.data = C.CString(context) - context_ms.len = C.size_t(len(context)) - defer C.free(unsafe.Pointer(context_ms.data)) - return (bool)(C.QScxmlCppDataModel_setScxmlProperty(this.h, name_ms, (*C.QVariant)(value.UnsafePointer()), context_ms)) -} - -func (this *QScxmlCppDataModel) InState(stateName string) bool { - stateName_ms := C.struct_miqt_string{} - stateName_ms.data = C.CString(stateName) - stateName_ms.len = C.size_t(len(stateName)) - defer C.free(unsafe.Pointer(stateName_ms.data)) - return (bool)(C.QScxmlCppDataModel_inState(this.h, stateName_ms)) -} - -func QScxmlCppDataModel_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.QScxmlCppDataModel_tr2(s_Cstring, c_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func QScxmlCppDataModel_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.QScxmlCppDataModel_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 -} - -// Sender can only be called from a QScxmlCppDataModel that was directly constructed. -func (this *QScxmlCppDataModel) Sender() *qt6.QObject { - - var _dynamic_cast_ok C.bool = false - _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlCppDataModel_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 QScxmlCppDataModel that was directly constructed. -func (this *QScxmlCppDataModel) SenderSignalIndex() int { - - var _dynamic_cast_ok C.bool = false - _method_ret := (int)(C.QScxmlCppDataModel_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 QScxmlCppDataModel that was directly constructed. -func (this *QScxmlCppDataModel) 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.QScxmlCppDataModel_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 QScxmlCppDataModel that was directly constructed. -func (this *QScxmlCppDataModel) IsSignalConnected(signal *qt6.QMetaMethod) bool { - - var _dynamic_cast_ok C.bool = false - _method_ret := (bool)(C.QScxmlCppDataModel_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 *QScxmlCppDataModel) callVirtualBase_Setup(initialDataValues map[string]qt6.QVariant) bool { - initialDataValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialDataValues)))) - defer C.free(unsafe.Pointer(initialDataValues_Keys_CArray)) - initialDataValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialDataValues)))) - defer C.free(unsafe.Pointer(initialDataValues_Values_CArray)) - initialDataValues_ctr := 0 - for initialDataValues_k, initialDataValues_v := range initialDataValues { - initialDataValues_k_ms := C.struct_miqt_string{} - initialDataValues_k_ms.data = C.CString(initialDataValues_k) - initialDataValues_k_ms.len = C.size_t(len(initialDataValues_k)) - defer C.free(unsafe.Pointer(initialDataValues_k_ms.data)) - initialDataValues_Keys_CArray[initialDataValues_ctr] = initialDataValues_k_ms - initialDataValues_Values_CArray[initialDataValues_ctr] = (*C.QVariant)(initialDataValues_v.UnsafePointer()) - initialDataValues_ctr++ - } - initialDataValues_mm := C.struct_miqt_map{ - len: C.size_t(len(initialDataValues)), - keys: unsafe.Pointer(initialDataValues_Keys_CArray), - values: unsafe.Pointer(initialDataValues_Values_CArray), - } - - return (bool)(C.QScxmlCppDataModel_virtualbase_setup(unsafe.Pointer(this.h), initialDataValues_mm)) - -} -func (this *QScxmlCppDataModel) OnSetup(slot func(super func(initialDataValues map[string]qt6.QVariant) bool, initialDataValues map[string]qt6.QVariant) bool) { - ok := C.QScxmlCppDataModel_override_virtual_setup(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCppDataModel_setup -func miqt_exec_callback_QScxmlCppDataModel_setup(self *C.QScxmlCppDataModel, cb C.intptr_t, initialDataValues C.struct_miqt_map) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(initialDataValues map[string]qt6.QVariant) bool, initialDataValues map[string]qt6.QVariant) bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var initialDataValues_mm C.struct_miqt_map = initialDataValues - initialDataValues_ret := make(map[string]qt6.QVariant, int(initialDataValues_mm.len)) - initialDataValues_Keys := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(initialDataValues_mm.keys)) - initialDataValues_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(initialDataValues_mm.values)) - for i := 0; i < int(initialDataValues_mm.len); i++ { - var initialDataValues_mapkey_ms C.struct_miqt_string = initialDataValues_Keys[i] - initialDataValues_mapkey_ret := C.GoStringN(initialDataValues_mapkey_ms.data, C.int(int64(initialDataValues_mapkey_ms.len))) - C.free(unsafe.Pointer(initialDataValues_mapkey_ms.data)) - initialDataValues_entry_Key := initialDataValues_mapkey_ret - initialDataValues_mapval_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(initialDataValues_Values[i])) - initialDataValues_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - initialDataValues_entry_Value := *initialDataValues_mapval_goptr - - initialDataValues_ret[initialDataValues_entry_Key] = initialDataValues_entry_Value - } - slotval1 := initialDataValues_ret - - virtualReturn := gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_Setup, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_EvaluateAssignment(id int, ok *bool) { - - C.QScxmlCppDataModel_virtualbase_evaluateAssignment(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) - -} -func (this *QScxmlCppDataModel) OnEvaluateAssignment(slot func(super func(id int, ok *bool), id int, ok *bool)) { - ok := C.QScxmlCppDataModel_override_virtual_evaluateAssignment(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCppDataModel_evaluateAssignment -func miqt_exec_callback_QScxmlCppDataModel_evaluateAssignment(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool) { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool), id int, ok *bool)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_EvaluateAssignment, slotval1, slotval2) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_EvaluateInitialization(id int, ok *bool) { - - C.QScxmlCppDataModel_virtualbase_evaluateInitialization(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) - -} -func (this *QScxmlCppDataModel) OnEvaluateInitialization(slot func(super func(id int, ok *bool), id int, ok *bool)) { - ok := C.QScxmlCppDataModel_override_virtual_evaluateInitialization(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCppDataModel_evaluateInitialization -func miqt_exec_callback_QScxmlCppDataModel_evaluateInitialization(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool) { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool), id int, ok *bool)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_EvaluateInitialization, slotval1, slotval2) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_EvaluateForeach(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody) { - - C.QScxmlCppDataModel_virtualbase_evaluateForeach(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok)), body.cPointer()) - -} -func (this *QScxmlCppDataModel) OnEvaluateForeach(slot func(super func(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody), id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody)) { - ok := C.QScxmlCppDataModel_override_virtual_evaluateForeach(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCppDataModel_evaluateForeach -func miqt_exec_callback_QScxmlCppDataModel_evaluateForeach(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool, body *C.QScxmlDataModel__ForeachLoopBody) { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody), id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - slotval3 := newQScxmlDataModel__ForeachLoopBody(body) - - gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_EvaluateForeach, slotval1, slotval2, slotval3) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_SetScxmlEvent(scxmlEvent *QScxmlEvent) { - - C.QScxmlCppDataModel_virtualbase_setScxmlEvent(unsafe.Pointer(this.h), scxmlEvent.cPointer()) - -} -func (this *QScxmlCppDataModel) OnSetScxmlEvent(slot func(super func(scxmlEvent *QScxmlEvent), scxmlEvent *QScxmlEvent)) { - ok := C.QScxmlCppDataModel_override_virtual_setScxmlEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCppDataModel_setScxmlEvent -func miqt_exec_callback_QScxmlCppDataModel_setScxmlEvent(self *C.QScxmlCppDataModel, cb C.intptr_t, scxmlEvent *C.QScxmlEvent) { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(scxmlEvent *QScxmlEvent), scxmlEvent *QScxmlEvent)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQScxmlEvent(scxmlEvent) - - gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_SetScxmlEvent, slotval1) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_ScxmlProperty(name string) *qt6.QVariant { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - - _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlCppDataModel_virtualbase_scxmlProperty(unsafe.Pointer(this.h), name_ms))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr - -} -func (this *QScxmlCppDataModel) OnScxmlProperty(slot func(super func(name string) *qt6.QVariant, name string) *qt6.QVariant) { - ok := C.QScxmlCppDataModel_override_virtual_scxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCppDataModel_scxmlProperty -func miqt_exec_callback_QScxmlCppDataModel_scxmlProperty(self *C.QScxmlCppDataModel, cb C.intptr_t, name C.struct_miqt_string) *C.QVariant { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(name string) *qt6.QVariant, name string) *qt6.QVariant) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var name_ms C.struct_miqt_string = name - name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) - C.free(unsafe.Pointer(name_ms.data)) - slotval1 := name_ret - - virtualReturn := gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_ScxmlProperty, slotval1) - - return (*C.QVariant)(virtualReturn.UnsafePointer()) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_HasScxmlProperty(name string) bool { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - - return (bool)(C.QScxmlCppDataModel_virtualbase_hasScxmlProperty(unsafe.Pointer(this.h), name_ms)) - -} -func (this *QScxmlCppDataModel) OnHasScxmlProperty(slot func(super func(name string) bool, name string) bool) { - ok := C.QScxmlCppDataModel_override_virtual_hasScxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCppDataModel_hasScxmlProperty -func miqt_exec_callback_QScxmlCppDataModel_hasScxmlProperty(self *C.QScxmlCppDataModel, cb C.intptr_t, name C.struct_miqt_string) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(name string) bool, name string) bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var name_ms C.struct_miqt_string = name - name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) - C.free(unsafe.Pointer(name_ms.data)) - slotval1 := name_ret - - virtualReturn := gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_HasScxmlProperty, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_SetScxmlProperty(name string, value *qt6.QVariant, context string) bool { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - context_ms := C.struct_miqt_string{} - context_ms.data = C.CString(context) - context_ms.len = C.size_t(len(context)) - defer C.free(unsafe.Pointer(context_ms.data)) - - return (bool)(C.QScxmlCppDataModel_virtualbase_setScxmlProperty(unsafe.Pointer(this.h), name_ms, (*C.QVariant)(value.UnsafePointer()), context_ms)) - -} -func (this *QScxmlCppDataModel) OnSetScxmlProperty(slot func(super func(name string, value *qt6.QVariant, context string) bool, name string, value *qt6.QVariant, context string) bool) { - ok := C.QScxmlCppDataModel_override_virtual_setScxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCppDataModel_setScxmlProperty -func miqt_exec_callback_QScxmlCppDataModel_setScxmlProperty(self *C.QScxmlCppDataModel, cb C.intptr_t, name C.struct_miqt_string, value *C.QVariant, context C.struct_miqt_string) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(name string, value *qt6.QVariant, context string) bool, name string, value *qt6.QVariant, context string) bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var name_ms C.struct_miqt_string = name - name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) - C.free(unsafe.Pointer(name_ms.data)) - slotval1 := name_ret - slotval2 := qt6.UnsafeNewQVariant(unsafe.Pointer(value)) - - var context_ms C.struct_miqt_string = context - context_ret := C.GoStringN(context_ms.data, C.int(int64(context_ms.len))) - C.free(unsafe.Pointer(context_ms.data)) - slotval3 := context_ret - - virtualReturn := gofunc((&QScxmlCppDataModel{h: self}).callVirtualBase_SetScxmlProperty, slotval1, slotval2, slotval3) - - return (C.bool)(virtualReturn) - -} -func (this *QScxmlCppDataModel) OnEvaluateToString(slot func(id int, ok *bool) string) { - ok := C.QScxmlCppDataModel_override_virtual_evaluateToString(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCppDataModel_evaluateToString -func miqt_exec_callback_QScxmlCppDataModel_evaluateToString(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool) C.struct_miqt_string { - gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool) string) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - virtualReturn := gofunc(slotval1, slotval2) - virtualReturn_ms := C.struct_miqt_string{} - virtualReturn_ms.data = C.CString(virtualReturn) - virtualReturn_ms.len = C.size_t(len(virtualReturn)) - defer C.free(unsafe.Pointer(virtualReturn_ms.data)) - - return virtualReturn_ms - -} -func (this *QScxmlCppDataModel) OnEvaluateToBool(slot func(id int, ok *bool) bool) { - ok := C.QScxmlCppDataModel_override_virtual_evaluateToBool(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCppDataModel_evaluateToBool -func miqt_exec_callback_QScxmlCppDataModel_evaluateToBool(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool) bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - virtualReturn := gofunc(slotval1, slotval2) - - return (C.bool)(virtualReturn) - -} -func (this *QScxmlCppDataModel) OnEvaluateToVariant(slot func(id int, ok *bool) *qt6.QVariant) { - ok := C.QScxmlCppDataModel_override_virtual_evaluateToVariant(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCppDataModel_evaluateToVariant -func miqt_exec_callback_QScxmlCppDataModel_evaluateToVariant(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool) *C.QVariant { - gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool) *qt6.QVariant) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - virtualReturn := gofunc(slotval1, slotval2) - - return (*C.QVariant)(virtualReturn.UnsafePointer()) - -} -func (this *QScxmlCppDataModel) OnEvaluateToVoid(slot func(id int, ok *bool)) { - ok := C.QScxmlCppDataModel_override_virtual_evaluateToVoid(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlCppDataModel_evaluateToVoid -func miqt_exec_callback_QScxmlCppDataModel_evaluateToVoid(self *C.QScxmlCppDataModel, cb C.intptr_t, id C.int, ok *C.bool) { - gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - gofunc(slotval1, slotval2) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_Event(event *qt6.QEvent) bool { - - return (bool)(C.QScxmlCppDataModel_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlCppDataModel) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { - ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_event -func miqt_exec_callback_QScxmlCppDataModel_event(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_Event, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { - - return (bool)(C.QScxmlCppDataModel_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlCppDataModel) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { - ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_eventFilter -func miqt_exec_callback_QScxmlCppDataModel_eventFilter(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { - - C.QScxmlCppDataModel_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) - -} -func (this *QScxmlCppDataModel) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { - ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_timerEvent -func miqt_exec_callback_QScxmlCppDataModel_timerEvent(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_TimerEvent, slotval1) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { - - C.QScxmlCppDataModel_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) - -} -func (this *QScxmlCppDataModel) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { - ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_childEvent -func miqt_exec_callback_QScxmlCppDataModel_childEvent(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_ChildEvent, slotval1) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_CustomEvent(event *qt6.QEvent) { - - C.QScxmlCppDataModel_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) - -} -func (this *QScxmlCppDataModel) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { - ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_customEvent -func miqt_exec_callback_QScxmlCppDataModel_customEvent(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_CustomEvent, slotval1) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlCppDataModel_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlCppDataModel) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_connectNotify -func miqt_exec_callback_QScxmlCppDataModel_connectNotify(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_ConnectNotify, slotval1) - -} - -func (this *QScxmlCppDataModel) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlCppDataModel_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlCppDataModel) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlCppDataModel_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_QScxmlCppDataModel_disconnectNotify -func miqt_exec_callback_QScxmlCppDataModel_disconnectNotify(self *C.QScxmlCppDataModel, 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((&QScxmlCppDataModel{h: self}).callVirtualBase_DisconnectNotify, slotval1) - -} - -// Delete this object from C++ memory. -func (this *QScxmlCppDataModel) Delete() { - C.QScxmlCppDataModel_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 *QScxmlCppDataModel) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlCppDataModel) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} diff --git a/qt6/scxml/gen_qscxmlcppdatamodel.h b/qt6/scxml/gen_qscxmlcppdatamodel.h deleted file mode 100644 index 0538e2a4a..000000000 --- a/qt6/scxml/gen_qscxmlcppdatamodel.h +++ /dev/null @@ -1,116 +0,0 @@ -#pragma once -#ifndef MIQT_QT6_SCXML_GEN_QSCXMLCPPDATAMODEL_H -#define MIQT_QT6_SCXML_GEN_QSCXMLCPPDATAMODEL_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 QScxmlCppDataModel; -class QScxmlDataModel; -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlDataModel__ForeachLoopBody) -typedef QScxmlDataModel::ForeachLoopBody QScxmlDataModel__ForeachLoopBody; -#else -class QScxmlDataModel__ForeachLoopBody; -#endif -class QScxmlEvent; -class QTimerEvent; -class QVariant; -#else -typedef struct QChildEvent QChildEvent; -typedef struct QEvent QEvent; -typedef struct QMetaMethod QMetaMethod; -typedef struct QMetaObject QMetaObject; -typedef struct QObject QObject; -typedef struct QScxmlCppDataModel QScxmlCppDataModel; -typedef struct QScxmlDataModel QScxmlDataModel; -typedef struct QScxmlDataModel__ForeachLoopBody QScxmlDataModel__ForeachLoopBody; -typedef struct QScxmlEvent QScxmlEvent; -typedef struct QTimerEvent QTimerEvent; -typedef struct QVariant QVariant; -#endif - -QScxmlCppDataModel* QScxmlCppDataModel_new(); -QScxmlCppDataModel* QScxmlCppDataModel_new2(QObject* parent); -void QScxmlCppDataModel_virtbase(QScxmlCppDataModel* src, QScxmlDataModel** outptr_QScxmlDataModel); -QMetaObject* QScxmlCppDataModel_metaObject(const QScxmlCppDataModel* self); -void* QScxmlCppDataModel_metacast(QScxmlCppDataModel* self, const char* param1); -struct miqt_string QScxmlCppDataModel_tr(const char* s); -bool QScxmlCppDataModel_setup(QScxmlCppDataModel* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); -void QScxmlCppDataModel_evaluateAssignment(QScxmlCppDataModel* self, int id, bool* ok); -void QScxmlCppDataModel_evaluateInitialization(QScxmlCppDataModel* self, int id, bool* ok); -void QScxmlCppDataModel_evaluateForeach(QScxmlCppDataModel* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); -void QScxmlCppDataModel_setScxmlEvent(QScxmlCppDataModel* self, QScxmlEvent* scxmlEvent); -QScxmlEvent* QScxmlCppDataModel_scxmlEvent(const QScxmlCppDataModel* self); -QVariant* QScxmlCppDataModel_scxmlProperty(const QScxmlCppDataModel* self, struct miqt_string name); -bool QScxmlCppDataModel_hasScxmlProperty(const QScxmlCppDataModel* self, struct miqt_string name); -bool QScxmlCppDataModel_setScxmlProperty(QScxmlCppDataModel* self, struct miqt_string name, QVariant* value, struct miqt_string context); -bool QScxmlCppDataModel_inState(const QScxmlCppDataModel* self, struct miqt_string stateName); -struct miqt_string QScxmlCppDataModel_tr2(const char* s, const char* c); -struct miqt_string QScxmlCppDataModel_tr3(const char* s, const char* c, int n); - -bool QScxmlCppDataModel_override_virtual_setup(void* self, intptr_t slot); -bool QScxmlCppDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); -bool QScxmlCppDataModel_override_virtual_evaluateAssignment(void* self, intptr_t slot); -void QScxmlCppDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok); -bool QScxmlCppDataModel_override_virtual_evaluateInitialization(void* self, intptr_t slot); -void QScxmlCppDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok); -bool QScxmlCppDataModel_override_virtual_evaluateForeach(void* self, intptr_t slot); -void QScxmlCppDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); -bool QScxmlCppDataModel_override_virtual_setScxmlEvent(void* self, intptr_t slot); -void QScxmlCppDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* scxmlEvent); -bool QScxmlCppDataModel_override_virtual_scxmlProperty(void* self, intptr_t slot); -QVariant* QScxmlCppDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name); -bool QScxmlCppDataModel_override_virtual_hasScxmlProperty(void* self, intptr_t slot); -bool QScxmlCppDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name); -bool QScxmlCppDataModel_override_virtual_setScxmlProperty(void* self, intptr_t slot); -bool QScxmlCppDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context); -bool QScxmlCppDataModel_override_virtual_evaluateToString(void* self, intptr_t slot); -struct miqt_string QScxmlCppDataModel_virtualbase_evaluateToString(void* self, int id, bool* ok); -bool QScxmlCppDataModel_override_virtual_evaluateToBool(void* self, intptr_t slot); -bool QScxmlCppDataModel_virtualbase_evaluateToBool(void* self, int id, bool* ok); -bool QScxmlCppDataModel_override_virtual_evaluateToVariant(void* self, intptr_t slot); -QVariant* QScxmlCppDataModel_virtualbase_evaluateToVariant(void* self, int id, bool* ok); -bool QScxmlCppDataModel_override_virtual_evaluateToVoid(void* self, intptr_t slot); -void QScxmlCppDataModel_virtualbase_evaluateToVoid(void* self, int id, bool* ok); -bool QScxmlCppDataModel_override_virtual_event(void* self, intptr_t slot); -bool QScxmlCppDataModel_virtualbase_event(void* self, QEvent* event); -bool QScxmlCppDataModel_override_virtual_eventFilter(void* self, intptr_t slot); -bool QScxmlCppDataModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); -bool QScxmlCppDataModel_override_virtual_timerEvent(void* self, intptr_t slot); -void QScxmlCppDataModel_virtualbase_timerEvent(void* self, QTimerEvent* event); -bool QScxmlCppDataModel_override_virtual_childEvent(void* self, intptr_t slot); -void QScxmlCppDataModel_virtualbase_childEvent(void* self, QChildEvent* event); -bool QScxmlCppDataModel_override_virtual_customEvent(void* self, intptr_t slot); -void QScxmlCppDataModel_virtualbase_customEvent(void* self, QEvent* event); -bool QScxmlCppDataModel_override_virtual_connectNotify(void* self, intptr_t slot); -void QScxmlCppDataModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); -bool QScxmlCppDataModel_override_virtual_disconnectNotify(void* self, intptr_t slot); -void QScxmlCppDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - -QObject* QScxmlCppDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); -int QScxmlCppDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); -int QScxmlCppDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); -bool QScxmlCppDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); - -void QScxmlCppDataModel_delete(QScxmlCppDataModel* self); - -#ifdef __cplusplus -} /* extern C */ -#endif - -#endif diff --git a/qt6/scxml/gen_qscxmldatamodel.cpp b/qt6/scxml/gen_qscxmldatamodel.cpp deleted file mode 100644 index a13c6bc9a..000000000 --- a/qt6/scxml/gen_qscxmldatamodel.cpp +++ /dev/null @@ -1,877 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlDataModel__ForeachLoopBody -#include -#include -#include -#include -#include -#include -#include -#include -#include "gen_qscxmldatamodel.h" - -#ifdef __cplusplus -extern "C" { -#endif - -void miqt_exec_callback_QScxmlDataModel_stateMachineChanged(intptr_t, QScxmlStateMachine*); -bool miqt_exec_callback_QScxmlDataModel_setup(QScxmlDataModel*, intptr_t, struct miqt_map /* of struct miqt_string to QVariant* */ ); -struct miqt_string miqt_exec_callback_QScxmlDataModel_evaluateToString(QScxmlDataModel*, intptr_t, int, bool*); -bool miqt_exec_callback_QScxmlDataModel_evaluateToBool(QScxmlDataModel*, intptr_t, int, bool*); -QVariant* miqt_exec_callback_QScxmlDataModel_evaluateToVariant(QScxmlDataModel*, intptr_t, int, bool*); -void miqt_exec_callback_QScxmlDataModel_evaluateToVoid(QScxmlDataModel*, intptr_t, int, bool*); -void miqt_exec_callback_QScxmlDataModel_evaluateAssignment(QScxmlDataModel*, intptr_t, int, bool*); -void miqt_exec_callback_QScxmlDataModel_evaluateInitialization(QScxmlDataModel*, intptr_t, int, bool*); -void miqt_exec_callback_QScxmlDataModel_evaluateForeach(QScxmlDataModel*, intptr_t, int, bool*, QScxmlDataModel__ForeachLoopBody*); -void miqt_exec_callback_QScxmlDataModel_setScxmlEvent(QScxmlDataModel*, intptr_t, QScxmlEvent*); -QVariant* miqt_exec_callback_QScxmlDataModel_scxmlProperty(const QScxmlDataModel*, intptr_t, struct miqt_string); -bool miqt_exec_callback_QScxmlDataModel_hasScxmlProperty(const QScxmlDataModel*, intptr_t, struct miqt_string); -bool miqt_exec_callback_QScxmlDataModel_setScxmlProperty(QScxmlDataModel*, intptr_t, struct miqt_string, QVariant*, struct miqt_string); -bool miqt_exec_callback_QScxmlDataModel_event(QScxmlDataModel*, intptr_t, QEvent*); -bool miqt_exec_callback_QScxmlDataModel_eventFilter(QScxmlDataModel*, intptr_t, QObject*, QEvent*); -void miqt_exec_callback_QScxmlDataModel_timerEvent(QScxmlDataModel*, intptr_t, QTimerEvent*); -void miqt_exec_callback_QScxmlDataModel_childEvent(QScxmlDataModel*, intptr_t, QChildEvent*); -void miqt_exec_callback_QScxmlDataModel_customEvent(QScxmlDataModel*, intptr_t, QEvent*); -void miqt_exec_callback_QScxmlDataModel_connectNotify(QScxmlDataModel*, intptr_t, QMetaMethod*); -void miqt_exec_callback_QScxmlDataModel_disconnectNotify(QScxmlDataModel*, intptr_t, QMetaMethod*); -void miqt_exec_callback_QScxmlDataModel__ForeachLoopBody_run(QScxmlDataModel__ForeachLoopBody*, intptr_t, bool*); -#ifdef __cplusplus -} /* extern C */ -#endif - -class MiqtVirtualQScxmlDataModel final : public QScxmlDataModel { -public: - - MiqtVirtualQScxmlDataModel(): QScxmlDataModel() {} - MiqtVirtualQScxmlDataModel(QObject* parent): QScxmlDataModel(parent) {} - - virtual ~MiqtVirtualQScxmlDataModel() override = default; - - // cgo.Handle value for overwritten implementation - intptr_t handle__setup = 0; - - // Subclass to allow providing a Go implementation - virtual bool setup(const QVariantMap& initialDataValues) override { - if (handle__setup == 0) { - return false; // Pure virtual, there is no base we can call - } - - const QVariantMap& initialDataValues_ret = initialDataValues; - // Convert QMap<> from C++ memory to manually-managed C memory - struct miqt_string* initialDataValues_karr = static_cast(malloc(sizeof(struct miqt_string) * initialDataValues_ret.size())); - QVariant** initialDataValues_varr = static_cast(malloc(sizeof(QVariant*) * initialDataValues_ret.size())); - int initialDataValues_ctr = 0; - for (auto initialDataValues_itr = initialDataValues_ret.keyValueBegin(); initialDataValues_itr != initialDataValues_ret.keyValueEnd(); ++initialDataValues_itr) { - QString initialDataValues_mapkey_ret = initialDataValues_itr->first; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray initialDataValues_mapkey_b = initialDataValues_mapkey_ret.toUtf8(); - struct miqt_string initialDataValues_mapkey_ms; - initialDataValues_mapkey_ms.len = initialDataValues_mapkey_b.length(); - initialDataValues_mapkey_ms.data = static_cast(malloc(initialDataValues_mapkey_ms.len)); - memcpy(initialDataValues_mapkey_ms.data, initialDataValues_mapkey_b.data(), initialDataValues_mapkey_ms.len); - initialDataValues_karr[initialDataValues_ctr] = initialDataValues_mapkey_ms; - initialDataValues_varr[initialDataValues_ctr] = new QVariant(initialDataValues_itr->second); - initialDataValues_ctr++; - } - struct miqt_map initialDataValues_out; - initialDataValues_out.len = initialDataValues_ret.size(); - initialDataValues_out.keys = static_cast(initialDataValues_karr); - initialDataValues_out.values = static_cast(initialDataValues_varr); - struct miqt_map /* of struct miqt_string to QVariant* */ sigval1 = initialDataValues_out; - bool callback_return_value = miqt_exec_callback_QScxmlDataModel_setup(this, handle__setup, sigval1); - return callback_return_value; - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateToString = 0; - - // Subclass to allow providing a Go implementation - virtual QString evaluateToString(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateToString == 0) { - return QString(); // Pure virtual, there is no base we can call - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - struct miqt_string callback_return_value = miqt_exec_callback_QScxmlDataModel_evaluateToString(this, handle__evaluateToString, sigval1, sigval2); - QString callback_return_value_QString = QString::fromUtf8(callback_return_value.data, callback_return_value.len); - return callback_return_value_QString; - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateToBool = 0; - - // Subclass to allow providing a Go implementation - virtual bool evaluateToBool(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateToBool == 0) { - return false; // Pure virtual, there is no base we can call - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - bool callback_return_value = miqt_exec_callback_QScxmlDataModel_evaluateToBool(this, handle__evaluateToBool, sigval1, sigval2); - return callback_return_value; - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateToVariant = 0; - - // Subclass to allow providing a Go implementation - virtual QVariant evaluateToVariant(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateToVariant == 0) { - return QVariant(); // Pure virtual, there is no base we can call - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - QVariant* callback_return_value = miqt_exec_callback_QScxmlDataModel_evaluateToVariant(this, handle__evaluateToVariant, sigval1, sigval2); - return *callback_return_value; - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateToVoid = 0; - - // Subclass to allow providing a Go implementation - virtual void evaluateToVoid(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateToVoid == 0) { - return; // Pure virtual, there is no base we can call - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - miqt_exec_callback_QScxmlDataModel_evaluateToVoid(this, handle__evaluateToVoid, sigval1, sigval2); - - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateAssignment = 0; - - // Subclass to allow providing a Go implementation - virtual void evaluateAssignment(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateAssignment == 0) { - return; // Pure virtual, there is no base we can call - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - miqt_exec_callback_QScxmlDataModel_evaluateAssignment(this, handle__evaluateAssignment, sigval1, sigval2); - - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateInitialization = 0; - - // Subclass to allow providing a Go implementation - virtual void evaluateInitialization(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateInitialization == 0) { - return; // Pure virtual, there is no base we can call - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - miqt_exec_callback_QScxmlDataModel_evaluateInitialization(this, handle__evaluateInitialization, sigval1, sigval2); - - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateForeach = 0; - - // Subclass to allow providing a Go implementation - virtual void evaluateForeach(QScxmlExecutableContent::EvaluatorId id, bool* ok, QScxmlDataModel::ForeachLoopBody* body) override { - if (handle__evaluateForeach == 0) { - return; // Pure virtual, there is no base we can call - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - QScxmlDataModel__ForeachLoopBody* sigval3 = body; - miqt_exec_callback_QScxmlDataModel_evaluateForeach(this, handle__evaluateForeach, sigval1, sigval2, sigval3); - - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__setScxmlEvent = 0; - - // Subclass to allow providing a Go implementation - virtual void setScxmlEvent(const QScxmlEvent& event) override { - if (handle__setScxmlEvent == 0) { - return; // Pure virtual, there is no base we can call - } - - const QScxmlEvent& event_ret = event; - // Cast returned reference into pointer - QScxmlEvent* sigval1 = const_cast(&event_ret); - miqt_exec_callback_QScxmlDataModel_setScxmlEvent(this, handle__setScxmlEvent, sigval1); - - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__scxmlProperty = 0; - - // Subclass to allow providing a Go implementation - virtual QVariant scxmlProperty(const QString& name) const override { - if (handle__scxmlProperty == 0) { - return QVariant(); // Pure virtual, there is no base we can call - } - - const QString name_ret = name; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray name_b = name_ret.toUtf8(); - struct miqt_string name_ms; - name_ms.len = name_b.length(); - name_ms.data = static_cast(malloc(name_ms.len)); - memcpy(name_ms.data, name_b.data(), name_ms.len); - struct miqt_string sigval1 = name_ms; - QVariant* callback_return_value = miqt_exec_callback_QScxmlDataModel_scxmlProperty(this, handle__scxmlProperty, sigval1); - return *callback_return_value; - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__hasScxmlProperty = 0; - - // Subclass to allow providing a Go implementation - virtual bool hasScxmlProperty(const QString& name) const override { - if (handle__hasScxmlProperty == 0) { - return false; // Pure virtual, there is no base we can call - } - - const QString name_ret = name; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray name_b = name_ret.toUtf8(); - struct miqt_string name_ms; - name_ms.len = name_b.length(); - name_ms.data = static_cast(malloc(name_ms.len)); - memcpy(name_ms.data, name_b.data(), name_ms.len); - struct miqt_string sigval1 = name_ms; - bool callback_return_value = miqt_exec_callback_QScxmlDataModel_hasScxmlProperty(this, handle__hasScxmlProperty, sigval1); - return callback_return_value; - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__setScxmlProperty = 0; - - // Subclass to allow providing a Go implementation - virtual bool setScxmlProperty(const QString& name, const QVariant& value, const QString& context) override { - if (handle__setScxmlProperty == 0) { - return false; // Pure virtual, there is no base we can call - } - - const QString name_ret = name; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray name_b = name_ret.toUtf8(); - struct miqt_string name_ms; - name_ms.len = name_b.length(); - name_ms.data = static_cast(malloc(name_ms.len)); - memcpy(name_ms.data, name_b.data(), name_ms.len); - struct miqt_string sigval1 = name_ms; - const QVariant& value_ret = value; - // Cast returned reference into pointer - QVariant* sigval2 = const_cast(&value_ret); - const QString context_ret = context; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray context_b = context_ret.toUtf8(); - struct miqt_string context_ms; - context_ms.len = context_b.length(); - context_ms.data = static_cast(malloc(context_ms.len)); - memcpy(context_ms.data, context_b.data(), context_ms.len); - struct miqt_string sigval3 = context_ms; - bool callback_return_value = miqt_exec_callback_QScxmlDataModel_setScxmlProperty(this, handle__setScxmlProperty, sigval1, sigval2, sigval3); - return callback_return_value; - } - - // 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 QScxmlDataModel::event(event); - } - - QEvent* sigval1 = event; - bool callback_return_value = miqt_exec_callback_QScxmlDataModel_event(this, handle__event, sigval1); - return callback_return_value; - } - - friend bool QScxmlDataModel_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 QScxmlDataModel::eventFilter(watched, event); - } - - QObject* sigval1 = watched; - QEvent* sigval2 = event; - bool callback_return_value = miqt_exec_callback_QScxmlDataModel_eventFilter(this, handle__eventFilter, sigval1, sigval2); - return callback_return_value; - } - - friend bool QScxmlDataModel_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) { - QScxmlDataModel::timerEvent(event); - return; - } - - QTimerEvent* sigval1 = event; - miqt_exec_callback_QScxmlDataModel_timerEvent(this, handle__timerEvent, sigval1); - - } - - friend void QScxmlDataModel_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) { - QScxmlDataModel::childEvent(event); - return; - } - - QChildEvent* sigval1 = event; - miqt_exec_callback_QScxmlDataModel_childEvent(this, handle__childEvent, sigval1); - - } - - friend void QScxmlDataModel_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) { - QScxmlDataModel::customEvent(event); - return; - } - - QEvent* sigval1 = event; - miqt_exec_callback_QScxmlDataModel_customEvent(this, handle__customEvent, sigval1); - - } - - friend void QScxmlDataModel_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) { - QScxmlDataModel::connectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlDataModel_connectNotify(this, handle__connectNotify, sigval1); - - } - - friend void QScxmlDataModel_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) { - QScxmlDataModel::disconnectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlDataModel_disconnectNotify(this, handle__disconnectNotify, sigval1); - - } - - friend void QScxmlDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - - // Wrappers to allow calling protected methods: - friend QObject* QScxmlDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); - friend bool QScxmlDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); -}; - -QScxmlDataModel* QScxmlDataModel_new() { - return new (std::nothrow) MiqtVirtualQScxmlDataModel(); -} - -QScxmlDataModel* QScxmlDataModel_new2(QObject* parent) { - return new (std::nothrow) MiqtVirtualQScxmlDataModel(parent); -} - -void QScxmlDataModel_virtbase(QScxmlDataModel* src, QObject** outptr_QObject) { - *outptr_QObject = static_cast(src); -} - -QMetaObject* QScxmlDataModel_metaObject(const QScxmlDataModel* self) { - return (QMetaObject*) self->metaObject(); -} - -void* QScxmlDataModel_metacast(QScxmlDataModel* self, const char* param1) { - return self->qt_metacast(param1); -} - -struct miqt_string QScxmlDataModel_tr(const char* s) { - QString _ret = QScxmlDataModel::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; -} - -QScxmlDataModel* QScxmlDataModel_createScxmlDataModel(struct miqt_string pluginKey) { - QString pluginKey_QString = QString::fromUtf8(pluginKey.data, pluginKey.len); - return QScxmlDataModel::createScxmlDataModel(pluginKey_QString); -} - -void QScxmlDataModel_setStateMachine(QScxmlDataModel* self, QScxmlStateMachine* stateMachine) { - self->setStateMachine(stateMachine); -} - -QScxmlStateMachine* QScxmlDataModel_stateMachine(const QScxmlDataModel* self) { - return self->stateMachine(); -} - -bool QScxmlDataModel_setup(QScxmlDataModel* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues) { - QVariantMap initialDataValues_QMap; - struct miqt_string* initialDataValues_karr = static_cast(initialDataValues.keys); - QVariant** initialDataValues_varr = static_cast(initialDataValues.values); - for(size_t i = 0; i < initialDataValues.len; ++i) { - QString initialDataValues_karr_i_QString = QString::fromUtf8(initialDataValues_karr[i].data, initialDataValues_karr[i].len); - initialDataValues_QMap[initialDataValues_karr_i_QString] = *(initialDataValues_varr[i]); - } - return self->setup(initialDataValues_QMap); -} - -struct miqt_string QScxmlDataModel_evaluateToString(QScxmlDataModel* self, int id, bool* ok) { - QString _ret = self->evaluateToString(static_cast(id), ok); - // 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 QScxmlDataModel_evaluateToBool(QScxmlDataModel* self, int id, bool* ok) { - return self->evaluateToBool(static_cast(id), ok); -} - -QVariant* QScxmlDataModel_evaluateToVariant(QScxmlDataModel* self, int id, bool* ok) { - return new QVariant(self->evaluateToVariant(static_cast(id), ok)); -} - -void QScxmlDataModel_evaluateToVoid(QScxmlDataModel* self, int id, bool* ok) { - self->evaluateToVoid(static_cast(id), ok); -} - -void QScxmlDataModel_evaluateAssignment(QScxmlDataModel* self, int id, bool* ok) { - self->evaluateAssignment(static_cast(id), ok); -} - -void QScxmlDataModel_evaluateInitialization(QScxmlDataModel* self, int id, bool* ok) { - self->evaluateInitialization(static_cast(id), ok); -} - -void QScxmlDataModel_evaluateForeach(QScxmlDataModel* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body) { - self->evaluateForeach(static_cast(id), ok, body); -} - -void QScxmlDataModel_setScxmlEvent(QScxmlDataModel* self, QScxmlEvent* event) { - self->setScxmlEvent(*event); -} - -QVariant* QScxmlDataModel_scxmlProperty(const QScxmlDataModel* self, struct miqt_string name) { - QString name_QString = QString::fromUtf8(name.data, name.len); - return new QVariant(self->scxmlProperty(name_QString)); -} - -bool QScxmlDataModel_hasScxmlProperty(const QScxmlDataModel* self, struct miqt_string name) { - QString name_QString = QString::fromUtf8(name.data, name.len); - return self->hasScxmlProperty(name_QString); -} - -bool QScxmlDataModel_setScxmlProperty(QScxmlDataModel* self, struct miqt_string name, QVariant* value, struct miqt_string context) { - QString name_QString = QString::fromUtf8(name.data, name.len); - QString context_QString = QString::fromUtf8(context.data, context.len); - return self->setScxmlProperty(name_QString, *value, context_QString); -} - -void QScxmlDataModel_stateMachineChanged(QScxmlDataModel* self, QScxmlStateMachine* stateMachine) { - self->stateMachineChanged(stateMachine); -} - -void QScxmlDataModel_connect_stateMachineChanged(QScxmlDataModel* self, intptr_t slot) { - QScxmlDataModel::connect(self, static_cast(&QScxmlDataModel::stateMachineChanged), self, [=](QScxmlStateMachine* stateMachine) { - QScxmlStateMachine* sigval1 = stateMachine; - miqt_exec_callback_QScxmlDataModel_stateMachineChanged(slot, sigval1); - }); -} - -struct miqt_string QScxmlDataModel_tr2(const char* s, const char* c) { - QString _ret = QScxmlDataModel::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 QScxmlDataModel_tr3(const char* s, const char* c, int n) { - QString _ret = QScxmlDataModel::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 QScxmlDataModel_override_virtual_setup(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__setup = slot; - return true; -} - -bool QScxmlDataModel_override_virtual_evaluateToString(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateToString = slot; - return true; -} - -bool QScxmlDataModel_override_virtual_evaluateToBool(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateToBool = slot; - return true; -} - -bool QScxmlDataModel_override_virtual_evaluateToVariant(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateToVariant = slot; - return true; -} - -bool QScxmlDataModel_override_virtual_evaluateToVoid(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateToVoid = slot; - return true; -} - -bool QScxmlDataModel_override_virtual_evaluateAssignment(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateAssignment = slot; - return true; -} - -bool QScxmlDataModel_override_virtual_evaluateInitialization(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateInitialization = slot; - return true; -} - -bool QScxmlDataModel_override_virtual_evaluateForeach(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateForeach = slot; - return true; -} - -bool QScxmlDataModel_override_virtual_setScxmlEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__setScxmlEvent = slot; - return true; -} - -bool QScxmlDataModel_override_virtual_scxmlProperty(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__scxmlProperty = slot; - return true; -} - -bool QScxmlDataModel_override_virtual_hasScxmlProperty(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__hasScxmlProperty = slot; - return true; -} - -bool QScxmlDataModel_override_virtual_setScxmlProperty(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__setScxmlProperty = slot; - return true; -} - -bool QScxmlDataModel_override_virtual_event(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__event = slot; - return true; -} - -bool QScxmlDataModel_virtualbase_event(void* self, QEvent* event) { - return static_cast(self)->QScxmlDataModel::event(event); -} - -bool QScxmlDataModel_override_virtual_eventFilter(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__eventFilter = slot; - return true; -} - -bool QScxmlDataModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { - return static_cast(self)->QScxmlDataModel::eventFilter(watched, event); -} - -bool QScxmlDataModel_override_virtual_timerEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__timerEvent = slot; - return true; -} - -void QScxmlDataModel_virtualbase_timerEvent(void* self, QTimerEvent* event) { - static_cast(self)->QScxmlDataModel::timerEvent(event); -} - -bool QScxmlDataModel_override_virtual_childEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__childEvent = slot; - return true; -} - -void QScxmlDataModel_virtualbase_childEvent(void* self, QChildEvent* event) { - static_cast(self)->QScxmlDataModel::childEvent(event); -} - -bool QScxmlDataModel_override_virtual_customEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__customEvent = slot; - return true; -} - -void QScxmlDataModel_virtualbase_customEvent(void* self, QEvent* event) { - static_cast(self)->QScxmlDataModel::customEvent(event); -} - -bool QScxmlDataModel_override_virtual_connectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__connectNotify = slot; - return true; -} - -void QScxmlDataModel_virtualbase_connectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlDataModel::connectNotify(*signal); -} - -bool QScxmlDataModel_override_virtual_disconnectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__disconnectNotify = slot; - return true; -} - -void QScxmlDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlDataModel::disconnectNotify(*signal); -} - -QObject* QScxmlDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return nullptr; - } - - *_dynamic_cast_ok = true; - return self_cast->sender(); -} - -int QScxmlDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->senderSignalIndex(); -} - -int QScxmlDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->receivers(signal); -} - -bool QScxmlDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { - MiqtVirtualQScxmlDataModel* self_cast = dynamic_cast( (QScxmlDataModel*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return false; - } - - *_dynamic_cast_ok = true; - return self_cast->isSignalConnected(*signal); -} - -void QScxmlDataModel_delete(QScxmlDataModel* self) { - delete self; -} - -class MiqtVirtualQScxmlDataModelForeachLoopBody final : public QScxmlDataModel::ForeachLoopBody { -public: - - MiqtVirtualQScxmlDataModelForeachLoopBody(): QScxmlDataModel::ForeachLoopBody() {} - - virtual ~MiqtVirtualQScxmlDataModelForeachLoopBody() override = default; - - // cgo.Handle value for overwritten implementation - intptr_t handle__run = 0; - - // Subclass to allow providing a Go implementation - virtual void run(bool* ok) override { - if (handle__run == 0) { - return; // Pure virtual, there is no base we can call - } - - bool* sigval1 = ok; - miqt_exec_callback_QScxmlDataModel__ForeachLoopBody_run(this, handle__run, sigval1); - - } - -}; - -QScxmlDataModel__ForeachLoopBody* QScxmlDataModel__ForeachLoopBody_new() { - return new (std::nothrow) MiqtVirtualQScxmlDataModelForeachLoopBody(); -} - -void QScxmlDataModel__ForeachLoopBody_run(QScxmlDataModel__ForeachLoopBody* self, bool* ok) { - self->run(ok); -} - -bool QScxmlDataModel__ForeachLoopBody_override_virtual_run(void* self, intptr_t slot) { - MiqtVirtualQScxmlDataModelForeachLoopBody* self_cast = dynamic_cast( (QScxmlDataModel::ForeachLoopBody*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__run = slot; - return true; -} - -void QScxmlDataModel__ForeachLoopBody_delete(QScxmlDataModel__ForeachLoopBody* self) { - delete self; -} - diff --git a/qt6/scxml/gen_qscxmldatamodel.go b/qt6/scxml/gen_qscxmldatamodel.go deleted file mode 100644 index 422ad8a39..000000000 --- a/qt6/scxml/gen_qscxmldatamodel.go +++ /dev/null @@ -1,871 +0,0 @@ -package scxml - -/* - -#include "gen_qscxmldatamodel.h" -#include - -*/ -import "C" - -import ( - "github.com/mappu/miqt/qt6" - "runtime" - "runtime/cgo" - "unsafe" -) - -type QScxmlDataModel struct { - h *C.QScxmlDataModel - *qt6.QObject -} - -func (this *QScxmlDataModel) cPointer() *C.QScxmlDataModel { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlDataModel) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlDataModel constructs the type using only CGO pointers. -func newQScxmlDataModel(h *C.QScxmlDataModel) *QScxmlDataModel { - if h == nil { - return nil - } - var outptr_QObject *C.QObject = nil - C.QScxmlDataModel_virtbase(h, &outptr_QObject) - - return &QScxmlDataModel{h: h, - QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} -} - -// UnsafeNewQScxmlDataModel constructs the type using only unsafe pointers. -func UnsafeNewQScxmlDataModel(h unsafe.Pointer) *QScxmlDataModel { - return newQScxmlDataModel((*C.QScxmlDataModel)(h)) -} - -// NewQScxmlDataModel constructs a new QScxmlDataModel object. -func NewQScxmlDataModel() *QScxmlDataModel { - - return newQScxmlDataModel(C.QScxmlDataModel_new()) -} - -// NewQScxmlDataModel2 constructs a new QScxmlDataModel object. -func NewQScxmlDataModel2(parent *qt6.QObject) *QScxmlDataModel { - - return newQScxmlDataModel(C.QScxmlDataModel_new2((*C.QObject)(parent.UnsafePointer()))) -} - -func (this *QScxmlDataModel) MetaObject() *qt6.QMetaObject { - return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlDataModel_metaObject(this.h))) -} - -func (this *QScxmlDataModel) Metacast(param1 string) unsafe.Pointer { - param1_Cstring := C.CString(param1) - defer C.free(unsafe.Pointer(param1_Cstring)) - return (unsafe.Pointer)(C.QScxmlDataModel_metacast(this.h, param1_Cstring)) -} - -func QScxmlDataModel_Tr(s string) string { - s_Cstring := C.CString(s) - defer C.free(unsafe.Pointer(s_Cstring)) - var _ms C.struct_miqt_string = C.QScxmlDataModel_tr(s_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func QScxmlDataModel_CreateScxmlDataModel(pluginKey string) *QScxmlDataModel { - pluginKey_ms := C.struct_miqt_string{} - pluginKey_ms.data = C.CString(pluginKey) - pluginKey_ms.len = C.size_t(len(pluginKey)) - defer C.free(unsafe.Pointer(pluginKey_ms.data)) - return newQScxmlDataModel(C.QScxmlDataModel_createScxmlDataModel(pluginKey_ms)) -} - -func (this *QScxmlDataModel) SetStateMachine(stateMachine *QScxmlStateMachine) { - C.QScxmlDataModel_setStateMachine(this.h, stateMachine.cPointer()) -} - -func (this *QScxmlDataModel) StateMachine() *QScxmlStateMachine { - return newQScxmlStateMachine(C.QScxmlDataModel_stateMachine(this.h)) -} - -func (this *QScxmlDataModel) Setup(initialDataValues map[string]qt6.QVariant) bool { - initialDataValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialDataValues)))) - defer C.free(unsafe.Pointer(initialDataValues_Keys_CArray)) - initialDataValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialDataValues)))) - defer C.free(unsafe.Pointer(initialDataValues_Values_CArray)) - initialDataValues_ctr := 0 - for initialDataValues_k, initialDataValues_v := range initialDataValues { - initialDataValues_k_ms := C.struct_miqt_string{} - initialDataValues_k_ms.data = C.CString(initialDataValues_k) - initialDataValues_k_ms.len = C.size_t(len(initialDataValues_k)) - defer C.free(unsafe.Pointer(initialDataValues_k_ms.data)) - initialDataValues_Keys_CArray[initialDataValues_ctr] = initialDataValues_k_ms - initialDataValues_Values_CArray[initialDataValues_ctr] = (*C.QVariant)(initialDataValues_v.UnsafePointer()) - initialDataValues_ctr++ - } - initialDataValues_mm := C.struct_miqt_map{ - len: C.size_t(len(initialDataValues)), - keys: unsafe.Pointer(initialDataValues_Keys_CArray), - values: unsafe.Pointer(initialDataValues_Values_CArray), - } - return (bool)(C.QScxmlDataModel_setup(this.h, initialDataValues_mm)) -} - -func (this *QScxmlDataModel) EvaluateToString(id int, ok *bool) string { - var _ms C.struct_miqt_string = C.QScxmlDataModel_evaluateToString(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlDataModel) EvaluateToBool(id int, ok *bool) bool { - return (bool)(C.QScxmlDataModel_evaluateToBool(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok)))) -} - -func (this *QScxmlDataModel) EvaluateToVariant(id int, ok *bool) *qt6.QVariant { - _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlDataModel_evaluateToVariant(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -func (this *QScxmlDataModel) EvaluateToVoid(id int, ok *bool) { - C.QScxmlDataModel_evaluateToVoid(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) -} - -func (this *QScxmlDataModel) EvaluateAssignment(id int, ok *bool) { - C.QScxmlDataModel_evaluateAssignment(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) -} - -func (this *QScxmlDataModel) EvaluateInitialization(id int, ok *bool) { - C.QScxmlDataModel_evaluateInitialization(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) -} - -func (this *QScxmlDataModel) EvaluateForeach(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody) { - C.QScxmlDataModel_evaluateForeach(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok)), body.cPointer()) -} - -func (this *QScxmlDataModel) SetScxmlEvent(event *QScxmlEvent) { - C.QScxmlDataModel_setScxmlEvent(this.h, event.cPointer()) -} - -func (this *QScxmlDataModel) ScxmlProperty(name string) *qt6.QVariant { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlDataModel_scxmlProperty(this.h, name_ms))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -func (this *QScxmlDataModel) HasScxmlProperty(name string) bool { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - return (bool)(C.QScxmlDataModel_hasScxmlProperty(this.h, name_ms)) -} - -func (this *QScxmlDataModel) SetScxmlProperty(name string, value *qt6.QVariant, context string) bool { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - context_ms := C.struct_miqt_string{} - context_ms.data = C.CString(context) - context_ms.len = C.size_t(len(context)) - defer C.free(unsafe.Pointer(context_ms.data)) - return (bool)(C.QScxmlDataModel_setScxmlProperty(this.h, name_ms, (*C.QVariant)(value.UnsafePointer()), context_ms)) -} - -func (this *QScxmlDataModel) StateMachineChanged(stateMachine *QScxmlStateMachine) { - C.QScxmlDataModel_stateMachineChanged(this.h, stateMachine.cPointer()) -} -func (this *QScxmlDataModel) OnStateMachineChanged(slot func(stateMachine *QScxmlStateMachine)) { - C.QScxmlDataModel_connect_stateMachineChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) -} - -//export miqt_exec_callback_QScxmlDataModel_stateMachineChanged -func miqt_exec_callback_QScxmlDataModel_stateMachineChanged(cb C.intptr_t, stateMachine *C.QScxmlStateMachine) { - gofunc, ok := cgo.Handle(cb).Value().(func(stateMachine *QScxmlStateMachine)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQScxmlStateMachine(stateMachine) - - gofunc(slotval1) -} - -func QScxmlDataModel_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.QScxmlDataModel_tr2(s_Cstring, c_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func QScxmlDataModel_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.QScxmlDataModel_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 -} - -// Sender can only be called from a QScxmlDataModel that was directly constructed. -func (this *QScxmlDataModel) Sender() *qt6.QObject { - - var _dynamic_cast_ok C.bool = false - _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlDataModel_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 QScxmlDataModel that was directly constructed. -func (this *QScxmlDataModel) SenderSignalIndex() int { - - var _dynamic_cast_ok C.bool = false - _method_ret := (int)(C.QScxmlDataModel_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 QScxmlDataModel that was directly constructed. -func (this *QScxmlDataModel) 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.QScxmlDataModel_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 QScxmlDataModel that was directly constructed. -func (this *QScxmlDataModel) IsSignalConnected(signal *qt6.QMetaMethod) bool { - - var _dynamic_cast_ok C.bool = false - _method_ret := (bool)(C.QScxmlDataModel_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 *QScxmlDataModel) OnSetup(slot func(initialDataValues map[string]qt6.QVariant) bool) { - ok := C.QScxmlDataModel_override_virtual_setup(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel_setup -func miqt_exec_callback_QScxmlDataModel_setup(self *C.QScxmlDataModel, cb C.intptr_t, initialDataValues C.struct_miqt_map) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func(initialDataValues map[string]qt6.QVariant) bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var initialDataValues_mm C.struct_miqt_map = initialDataValues - initialDataValues_ret := make(map[string]qt6.QVariant, int(initialDataValues_mm.len)) - initialDataValues_Keys := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(initialDataValues_mm.keys)) - initialDataValues_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(initialDataValues_mm.values)) - for i := 0; i < int(initialDataValues_mm.len); i++ { - var initialDataValues_mapkey_ms C.struct_miqt_string = initialDataValues_Keys[i] - initialDataValues_mapkey_ret := C.GoStringN(initialDataValues_mapkey_ms.data, C.int(int64(initialDataValues_mapkey_ms.len))) - C.free(unsafe.Pointer(initialDataValues_mapkey_ms.data)) - initialDataValues_entry_Key := initialDataValues_mapkey_ret - initialDataValues_mapval_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(initialDataValues_Values[i])) - initialDataValues_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - initialDataValues_entry_Value := *initialDataValues_mapval_goptr - - initialDataValues_ret[initialDataValues_entry_Key] = initialDataValues_entry_Value - } - slotval1 := initialDataValues_ret - - virtualReturn := gofunc(slotval1) - - return (C.bool)(virtualReturn) - -} -func (this *QScxmlDataModel) OnEvaluateToString(slot func(id int, ok *bool) string) { - ok := C.QScxmlDataModel_override_virtual_evaluateToString(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel_evaluateToString -func miqt_exec_callback_QScxmlDataModel_evaluateToString(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool) C.struct_miqt_string { - gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool) string) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - virtualReturn := gofunc(slotval1, slotval2) - virtualReturn_ms := C.struct_miqt_string{} - virtualReturn_ms.data = C.CString(virtualReturn) - virtualReturn_ms.len = C.size_t(len(virtualReturn)) - defer C.free(unsafe.Pointer(virtualReturn_ms.data)) - - return virtualReturn_ms - -} -func (this *QScxmlDataModel) OnEvaluateToBool(slot func(id int, ok *bool) bool) { - ok := C.QScxmlDataModel_override_virtual_evaluateToBool(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel_evaluateToBool -func miqt_exec_callback_QScxmlDataModel_evaluateToBool(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool) bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - virtualReturn := gofunc(slotval1, slotval2) - - return (C.bool)(virtualReturn) - -} -func (this *QScxmlDataModel) OnEvaluateToVariant(slot func(id int, ok *bool) *qt6.QVariant) { - ok := C.QScxmlDataModel_override_virtual_evaluateToVariant(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel_evaluateToVariant -func miqt_exec_callback_QScxmlDataModel_evaluateToVariant(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool) *C.QVariant { - gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool) *qt6.QVariant) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - virtualReturn := gofunc(slotval1, slotval2) - - return (*C.QVariant)(virtualReturn.UnsafePointer()) - -} -func (this *QScxmlDataModel) OnEvaluateToVoid(slot func(id int, ok *bool)) { - ok := C.QScxmlDataModel_override_virtual_evaluateToVoid(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel_evaluateToVoid -func miqt_exec_callback_QScxmlDataModel_evaluateToVoid(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool) { - gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - gofunc(slotval1, slotval2) - -} -func (this *QScxmlDataModel) OnEvaluateAssignment(slot func(id int, ok *bool)) { - ok := C.QScxmlDataModel_override_virtual_evaluateAssignment(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel_evaluateAssignment -func miqt_exec_callback_QScxmlDataModel_evaluateAssignment(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool) { - gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - gofunc(slotval1, slotval2) - -} -func (this *QScxmlDataModel) OnEvaluateInitialization(slot func(id int, ok *bool)) { - ok := C.QScxmlDataModel_override_virtual_evaluateInitialization(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel_evaluateInitialization -func miqt_exec_callback_QScxmlDataModel_evaluateInitialization(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool) { - gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - gofunc(slotval1, slotval2) - -} -func (this *QScxmlDataModel) OnEvaluateForeach(slot func(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody)) { - ok := C.QScxmlDataModel_override_virtual_evaluateForeach(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel_evaluateForeach -func miqt_exec_callback_QScxmlDataModel_evaluateForeach(self *C.QScxmlDataModel, cb C.intptr_t, id C.int, ok *C.bool, body *C.QScxmlDataModel__ForeachLoopBody) { - gofunc, ok := cgo.Handle(cb).Value().(func(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - slotval3 := newQScxmlDataModel__ForeachLoopBody(body) - - gofunc(slotval1, slotval2, slotval3) - -} -func (this *QScxmlDataModel) OnSetScxmlEvent(slot func(event *QScxmlEvent)) { - ok := C.QScxmlDataModel_override_virtual_setScxmlEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel_setScxmlEvent -func miqt_exec_callback_QScxmlDataModel_setScxmlEvent(self *C.QScxmlDataModel, cb C.intptr_t, event *C.QScxmlEvent) { - gofunc, ok := cgo.Handle(cb).Value().(func(event *QScxmlEvent)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQScxmlEvent(event) - - gofunc(slotval1) - -} -func (this *QScxmlDataModel) OnScxmlProperty(slot func(name string) *qt6.QVariant) { - ok := C.QScxmlDataModel_override_virtual_scxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel_scxmlProperty -func miqt_exec_callback_QScxmlDataModel_scxmlProperty(self *C.QScxmlDataModel, cb C.intptr_t, name C.struct_miqt_string) *C.QVariant { - gofunc, ok := cgo.Handle(cb).Value().(func(name string) *qt6.QVariant) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var name_ms C.struct_miqt_string = name - name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) - C.free(unsafe.Pointer(name_ms.data)) - slotval1 := name_ret - - virtualReturn := gofunc(slotval1) - - return (*C.QVariant)(virtualReturn.UnsafePointer()) - -} -func (this *QScxmlDataModel) OnHasScxmlProperty(slot func(name string) bool) { - ok := C.QScxmlDataModel_override_virtual_hasScxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel_hasScxmlProperty -func miqt_exec_callback_QScxmlDataModel_hasScxmlProperty(self *C.QScxmlDataModel, cb C.intptr_t, name C.struct_miqt_string) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func(name string) bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var name_ms C.struct_miqt_string = name - name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) - C.free(unsafe.Pointer(name_ms.data)) - slotval1 := name_ret - - virtualReturn := gofunc(slotval1) - - return (C.bool)(virtualReturn) - -} -func (this *QScxmlDataModel) OnSetScxmlProperty(slot func(name string, value *qt6.QVariant, context string) bool) { - ok := C.QScxmlDataModel_override_virtual_setScxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel_setScxmlProperty -func miqt_exec_callback_QScxmlDataModel_setScxmlProperty(self *C.QScxmlDataModel, cb C.intptr_t, name C.struct_miqt_string, value *C.QVariant, context C.struct_miqt_string) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func(name string, value *qt6.QVariant, context string) bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var name_ms C.struct_miqt_string = name - name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) - C.free(unsafe.Pointer(name_ms.data)) - slotval1 := name_ret - slotval2 := qt6.UnsafeNewQVariant(unsafe.Pointer(value)) - - var context_ms C.struct_miqt_string = context - context_ret := C.GoStringN(context_ms.data, C.int(int64(context_ms.len))) - C.free(unsafe.Pointer(context_ms.data)) - slotval3 := context_ret - - virtualReturn := gofunc(slotval1, slotval2, slotval3) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlDataModel) callVirtualBase_Event(event *qt6.QEvent) bool { - - return (bool)(C.QScxmlDataModel_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlDataModel) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { - ok := C.QScxmlDataModel_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_QScxmlDataModel_event -func miqt_exec_callback_QScxmlDataModel_event(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_Event, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlDataModel) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { - - return (bool)(C.QScxmlDataModel_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlDataModel) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { - ok := C.QScxmlDataModel_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_QScxmlDataModel_eventFilter -func miqt_exec_callback_QScxmlDataModel_eventFilter(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlDataModel) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { - - C.QScxmlDataModel_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) - -} -func (this *QScxmlDataModel) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { - ok := C.QScxmlDataModel_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_QScxmlDataModel_timerEvent -func miqt_exec_callback_QScxmlDataModel_timerEvent(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_TimerEvent, slotval1) - -} - -func (this *QScxmlDataModel) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { - - C.QScxmlDataModel_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) - -} -func (this *QScxmlDataModel) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { - ok := C.QScxmlDataModel_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_QScxmlDataModel_childEvent -func miqt_exec_callback_QScxmlDataModel_childEvent(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_ChildEvent, slotval1) - -} - -func (this *QScxmlDataModel) callVirtualBase_CustomEvent(event *qt6.QEvent) { - - C.QScxmlDataModel_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) - -} -func (this *QScxmlDataModel) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { - ok := C.QScxmlDataModel_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_QScxmlDataModel_customEvent -func miqt_exec_callback_QScxmlDataModel_customEvent(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_CustomEvent, slotval1) - -} - -func (this *QScxmlDataModel) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlDataModel_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlDataModel) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlDataModel_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_QScxmlDataModel_connectNotify -func miqt_exec_callback_QScxmlDataModel_connectNotify(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_ConnectNotify, slotval1) - -} - -func (this *QScxmlDataModel) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlDataModel_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlDataModel) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlDataModel_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_QScxmlDataModel_disconnectNotify -func miqt_exec_callback_QScxmlDataModel_disconnectNotify(self *C.QScxmlDataModel, 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((&QScxmlDataModel{h: self}).callVirtualBase_DisconnectNotify, slotval1) - -} - -// Delete this object from C++ memory. -func (this *QScxmlDataModel) Delete() { - C.QScxmlDataModel_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 *QScxmlDataModel) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlDataModel) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} - -type QScxmlDataModel__ForeachLoopBody struct { - h *C.QScxmlDataModel__ForeachLoopBody -} - -func (this *QScxmlDataModel__ForeachLoopBody) cPointer() *C.QScxmlDataModel__ForeachLoopBody { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlDataModel__ForeachLoopBody) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlDataModel__ForeachLoopBody constructs the type using only CGO pointers. -func newQScxmlDataModel__ForeachLoopBody(h *C.QScxmlDataModel__ForeachLoopBody) *QScxmlDataModel__ForeachLoopBody { - if h == nil { - return nil - } - - return &QScxmlDataModel__ForeachLoopBody{h: h} -} - -// UnsafeNewQScxmlDataModel__ForeachLoopBody constructs the type using only unsafe pointers. -func UnsafeNewQScxmlDataModel__ForeachLoopBody(h unsafe.Pointer) *QScxmlDataModel__ForeachLoopBody { - return newQScxmlDataModel__ForeachLoopBody((*C.QScxmlDataModel__ForeachLoopBody)(h)) -} - -// NewQScxmlDataModel__ForeachLoopBody constructs a new QScxmlDataModel::ForeachLoopBody object. -func NewQScxmlDataModel__ForeachLoopBody() *QScxmlDataModel__ForeachLoopBody { - - return newQScxmlDataModel__ForeachLoopBody(C.QScxmlDataModel__ForeachLoopBody_new()) -} - -func (this *QScxmlDataModel__ForeachLoopBody) Run(ok *bool) { - C.QScxmlDataModel__ForeachLoopBody_run(this.h, (*C.bool)(unsafe.Pointer(ok))) -} -func (this *QScxmlDataModel__ForeachLoopBody) OnRun(slot func(ok *bool)) { - ok := C.QScxmlDataModel__ForeachLoopBody_override_virtual_run(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDataModel__ForeachLoopBody_run -func miqt_exec_callback_QScxmlDataModel__ForeachLoopBody_run(self *C.QScxmlDataModel__ForeachLoopBody, cb C.intptr_t, ok *C.bool) { - gofunc, ok := cgo.Handle(cb).Value().(func(ok *bool)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (*bool)(unsafe.Pointer(ok)) - - gofunc(slotval1) - -} - -// Delete this object from C++ memory. -func (this *QScxmlDataModel__ForeachLoopBody) Delete() { - C.QScxmlDataModel__ForeachLoopBody_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 *QScxmlDataModel__ForeachLoopBody) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlDataModel__ForeachLoopBody) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} diff --git a/qt6/scxml/gen_qscxmldatamodel.h b/qt6/scxml/gen_qscxmldatamodel.h deleted file mode 100644 index 825df0830..000000000 --- a/qt6/scxml/gen_qscxmldatamodel.h +++ /dev/null @@ -1,131 +0,0 @@ -#pragma once -#ifndef MIQT_QT6_SCXML_GEN_QSCXMLDATAMODEL_H -#define MIQT_QT6_SCXML_GEN_QSCXMLDATAMODEL_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 QScxmlDataModel; -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlDataModel__ForeachLoopBody) -typedef QScxmlDataModel::ForeachLoopBody QScxmlDataModel__ForeachLoopBody; -#else -class QScxmlDataModel__ForeachLoopBody; -#endif -class QScxmlEvent; -class QScxmlStateMachine; -class QTimerEvent; -class QVariant; -#else -typedef struct QChildEvent QChildEvent; -typedef struct QEvent QEvent; -typedef struct QMetaMethod QMetaMethod; -typedef struct QMetaObject QMetaObject; -typedef struct QObject QObject; -typedef struct QScxmlDataModel QScxmlDataModel; -typedef struct QScxmlDataModel__ForeachLoopBody QScxmlDataModel__ForeachLoopBody; -typedef struct QScxmlEvent QScxmlEvent; -typedef struct QScxmlStateMachine QScxmlStateMachine; -typedef struct QTimerEvent QTimerEvent; -typedef struct QVariant QVariant; -#endif - -QScxmlDataModel* QScxmlDataModel_new(); -QScxmlDataModel* QScxmlDataModel_new2(QObject* parent); -void QScxmlDataModel_virtbase(QScxmlDataModel* src, QObject** outptr_QObject); -QMetaObject* QScxmlDataModel_metaObject(const QScxmlDataModel* self); -void* QScxmlDataModel_metacast(QScxmlDataModel* self, const char* param1); -struct miqt_string QScxmlDataModel_tr(const char* s); -QScxmlDataModel* QScxmlDataModel_createScxmlDataModel(struct miqt_string pluginKey); -void QScxmlDataModel_setStateMachine(QScxmlDataModel* self, QScxmlStateMachine* stateMachine); -QScxmlStateMachine* QScxmlDataModel_stateMachine(const QScxmlDataModel* self); -bool QScxmlDataModel_setup(QScxmlDataModel* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); -struct miqt_string QScxmlDataModel_evaluateToString(QScxmlDataModel* self, int id, bool* ok); -bool QScxmlDataModel_evaluateToBool(QScxmlDataModel* self, int id, bool* ok); -QVariant* QScxmlDataModel_evaluateToVariant(QScxmlDataModel* self, int id, bool* ok); -void QScxmlDataModel_evaluateToVoid(QScxmlDataModel* self, int id, bool* ok); -void QScxmlDataModel_evaluateAssignment(QScxmlDataModel* self, int id, bool* ok); -void QScxmlDataModel_evaluateInitialization(QScxmlDataModel* self, int id, bool* ok); -void QScxmlDataModel_evaluateForeach(QScxmlDataModel* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); -void QScxmlDataModel_setScxmlEvent(QScxmlDataModel* self, QScxmlEvent* event); -QVariant* QScxmlDataModel_scxmlProperty(const QScxmlDataModel* self, struct miqt_string name); -bool QScxmlDataModel_hasScxmlProperty(const QScxmlDataModel* self, struct miqt_string name); -bool QScxmlDataModel_setScxmlProperty(QScxmlDataModel* self, struct miqt_string name, QVariant* value, struct miqt_string context); -void QScxmlDataModel_stateMachineChanged(QScxmlDataModel* self, QScxmlStateMachine* stateMachine); -void QScxmlDataModel_connect_stateMachineChanged(QScxmlDataModel* self, intptr_t slot); -struct miqt_string QScxmlDataModel_tr2(const char* s, const char* c); -struct miqt_string QScxmlDataModel_tr3(const char* s, const char* c, int n); - -bool QScxmlDataModel_override_virtual_setup(void* self, intptr_t slot); -bool QScxmlDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); -bool QScxmlDataModel_override_virtual_evaluateToString(void* self, intptr_t slot); -struct miqt_string QScxmlDataModel_virtualbase_evaluateToString(void* self, int id, bool* ok); -bool QScxmlDataModel_override_virtual_evaluateToBool(void* self, intptr_t slot); -bool QScxmlDataModel_virtualbase_evaluateToBool(void* self, int id, bool* ok); -bool QScxmlDataModel_override_virtual_evaluateToVariant(void* self, intptr_t slot); -QVariant* QScxmlDataModel_virtualbase_evaluateToVariant(void* self, int id, bool* ok); -bool QScxmlDataModel_override_virtual_evaluateToVoid(void* self, intptr_t slot); -void QScxmlDataModel_virtualbase_evaluateToVoid(void* self, int id, bool* ok); -bool QScxmlDataModel_override_virtual_evaluateAssignment(void* self, intptr_t slot); -void QScxmlDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok); -bool QScxmlDataModel_override_virtual_evaluateInitialization(void* self, intptr_t slot); -void QScxmlDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok); -bool QScxmlDataModel_override_virtual_evaluateForeach(void* self, intptr_t slot); -void QScxmlDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); -bool QScxmlDataModel_override_virtual_setScxmlEvent(void* self, intptr_t slot); -void QScxmlDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* event); -bool QScxmlDataModel_override_virtual_scxmlProperty(void* self, intptr_t slot); -QVariant* QScxmlDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name); -bool QScxmlDataModel_override_virtual_hasScxmlProperty(void* self, intptr_t slot); -bool QScxmlDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name); -bool QScxmlDataModel_override_virtual_setScxmlProperty(void* self, intptr_t slot); -bool QScxmlDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context); -bool QScxmlDataModel_override_virtual_event(void* self, intptr_t slot); -bool QScxmlDataModel_virtualbase_event(void* self, QEvent* event); -bool QScxmlDataModel_override_virtual_eventFilter(void* self, intptr_t slot); -bool QScxmlDataModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); -bool QScxmlDataModel_override_virtual_timerEvent(void* self, intptr_t slot); -void QScxmlDataModel_virtualbase_timerEvent(void* self, QTimerEvent* event); -bool QScxmlDataModel_override_virtual_childEvent(void* self, intptr_t slot); -void QScxmlDataModel_virtualbase_childEvent(void* self, QChildEvent* event); -bool QScxmlDataModel_override_virtual_customEvent(void* self, intptr_t slot); -void QScxmlDataModel_virtualbase_customEvent(void* self, QEvent* event); -bool QScxmlDataModel_override_virtual_connectNotify(void* self, intptr_t slot); -void QScxmlDataModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); -bool QScxmlDataModel_override_virtual_disconnectNotify(void* self, intptr_t slot); -void QScxmlDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - -QObject* QScxmlDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); -int QScxmlDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); -int QScxmlDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); -bool QScxmlDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); - -void QScxmlDataModel_delete(QScxmlDataModel* self); - -QScxmlDataModel__ForeachLoopBody* QScxmlDataModel__ForeachLoopBody_new(); -void QScxmlDataModel__ForeachLoopBody_run(QScxmlDataModel__ForeachLoopBody* self, bool* ok); - -bool QScxmlDataModel__ForeachLoopBody_override_virtual_run(void* self, intptr_t slot); -void QScxmlDataModel__ForeachLoopBody_virtualbase_run(void* self, bool* ok); - -void QScxmlDataModel__ForeachLoopBody_delete(QScxmlDataModel__ForeachLoopBody* self); - -#ifdef __cplusplus -} /* extern C */ -#endif - -#endif diff --git a/qt6/scxml/gen_qscxmlerror.cpp b/qt6/scxml/gen_qscxmlerror.cpp deleted file mode 100644 index 34592426b..000000000 --- a/qt6/scxml/gen_qscxmlerror.cpp +++ /dev/null @@ -1,82 +0,0 @@ -#include -#include -#include -#include -#include -#include "gen_qscxmlerror.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __cplusplus -} /* extern C */ -#endif - -QScxmlError* QScxmlError_new() { - return new (std::nothrow) QScxmlError(); -} - -QScxmlError* QScxmlError_new2(struct miqt_string fileName, int line, int column, struct miqt_string description) { - QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); - QString description_QString = QString::fromUtf8(description.data, description.len); - return new (std::nothrow) QScxmlError(fileName_QString, static_cast(line), static_cast(column), description_QString); -} - -QScxmlError* QScxmlError_new3(QScxmlError* param1) { - return new (std::nothrow) QScxmlError(*param1); -} - -void QScxmlError_operatorAssign(QScxmlError* self, QScxmlError* param1) { - self->operator=(*param1); -} - -bool QScxmlError_isValid(const QScxmlError* self) { - return self->isValid(); -} - -struct miqt_string QScxmlError_fileName(const QScxmlError* self) { - QString _ret = self->fileName(); - // 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 QScxmlError_line(const QScxmlError* self) { - return self->line(); -} - -int QScxmlError_column(const QScxmlError* self) { - return self->column(); -} - -struct miqt_string QScxmlError_description(const QScxmlError* self) { - QString _ret = self->description(); - // 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 QScxmlError_toString(const QScxmlError* 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 QScxmlError_delete(QScxmlError* self) { - delete self; -} - diff --git a/qt6/scxml/gen_qscxmlerror.go b/qt6/scxml/gen_qscxmlerror.go deleted file mode 100644 index 5bfabfa55..000000000 --- a/qt6/scxml/gen_qscxmlerror.go +++ /dev/null @@ -1,123 +0,0 @@ -package scxml - -/* - -#include "gen_qscxmlerror.h" -#include - -*/ -import "C" - -import ( - "runtime" - "unsafe" -) - -type QScxmlError struct { - h *C.QScxmlError -} - -func (this *QScxmlError) cPointer() *C.QScxmlError { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlError) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlError constructs the type using only CGO pointers. -func newQScxmlError(h *C.QScxmlError) *QScxmlError { - if h == nil { - return nil - } - - return &QScxmlError{h: h} -} - -// UnsafeNewQScxmlError constructs the type using only unsafe pointers. -func UnsafeNewQScxmlError(h unsafe.Pointer) *QScxmlError { - return newQScxmlError((*C.QScxmlError)(h)) -} - -// NewQScxmlError constructs a new QScxmlError object. -func NewQScxmlError() *QScxmlError { - - return newQScxmlError(C.QScxmlError_new()) -} - -// NewQScxmlError2 constructs a new QScxmlError object. -func NewQScxmlError2(fileName string, line int, column int, description string) *QScxmlError { - 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)) - description_ms := C.struct_miqt_string{} - description_ms.data = C.CString(description) - description_ms.len = C.size_t(len(description)) - defer C.free(unsafe.Pointer(description_ms.data)) - - return newQScxmlError(C.QScxmlError_new2(fileName_ms, (C.int)(line), (C.int)(column), description_ms)) -} - -// NewQScxmlError3 constructs a new QScxmlError object. -func NewQScxmlError3(param1 *QScxmlError) *QScxmlError { - - return newQScxmlError(C.QScxmlError_new3(param1.cPointer())) -} - -func (this *QScxmlError) OperatorAssign(param1 *QScxmlError) { - C.QScxmlError_operatorAssign(this.h, param1.cPointer()) -} - -func (this *QScxmlError) IsValid() bool { - return (bool)(C.QScxmlError_isValid(this.h)) -} - -func (this *QScxmlError) FileName() string { - var _ms C.struct_miqt_string = C.QScxmlError_fileName(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlError) Line() int { - return (int)(C.QScxmlError_line(this.h)) -} - -func (this *QScxmlError) Column() int { - return (int)(C.QScxmlError_column(this.h)) -} - -func (this *QScxmlError) Description() string { - var _ms C.struct_miqt_string = C.QScxmlError_description(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlError) ToString() string { - var _ms C.struct_miqt_string = C.QScxmlError_toString(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -// Delete this object from C++ memory. -func (this *QScxmlError) Delete() { - C.QScxmlError_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 *QScxmlError) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlError) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} diff --git a/qt6/scxml/gen_qscxmlerror.h b/qt6/scxml/gen_qscxmlerror.h deleted file mode 100644 index e03d963c9..000000000 --- a/qt6/scxml/gen_qscxmlerror.h +++ /dev/null @@ -1,40 +0,0 @@ -#pragma once -#ifndef MIQT_QT6_SCXML_GEN_QSCXMLERROR_H -#define MIQT_QT6_SCXML_GEN_QSCXMLERROR_H - -#include -#include -#include - -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - -#include "../../libmiqt/libmiqt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __cplusplus -class QScxmlError; -#else -typedef struct QScxmlError QScxmlError; -#endif - -QScxmlError* QScxmlError_new(); -QScxmlError* QScxmlError_new2(struct miqt_string fileName, int line, int column, struct miqt_string description); -QScxmlError* QScxmlError_new3(QScxmlError* param1); -void QScxmlError_operatorAssign(QScxmlError* self, QScxmlError* param1); -bool QScxmlError_isValid(const QScxmlError* self); -struct miqt_string QScxmlError_fileName(const QScxmlError* self); -int QScxmlError_line(const QScxmlError* self); -int QScxmlError_column(const QScxmlError* self); -struct miqt_string QScxmlError_description(const QScxmlError* self); -struct miqt_string QScxmlError_toString(const QScxmlError* self); - -void QScxmlError_delete(QScxmlError* self); - -#ifdef __cplusplus -} /* extern C */ -#endif - -#endif diff --git a/qt6/scxml/gen_qscxmlevent.cpp b/qt6/scxml/gen_qscxmlevent.cpp deleted file mode 100644 index 17fd04574..000000000 --- a/qt6/scxml/gen_qscxmlevent.cpp +++ /dev/null @@ -1,172 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include "gen_qscxmlevent.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __cplusplus -} /* extern C */ -#endif - -QScxmlEvent* QScxmlEvent_new() { - return new (std::nothrow) QScxmlEvent(); -} - -QScxmlEvent* QScxmlEvent_new2(QScxmlEvent* other) { - return new (std::nothrow) QScxmlEvent(*other); -} - -void QScxmlEvent_operatorAssign(QScxmlEvent* self, QScxmlEvent* other) { - self->operator=(*other); -} - -struct miqt_string QScxmlEvent_name(const QScxmlEvent* self) { - QString _ret = self->name(); - // 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 QScxmlEvent_setName(QScxmlEvent* self, struct miqt_string name) { - QString name_QString = QString::fromUtf8(name.data, name.len); - self->setName(name_QString); -} - -int QScxmlEvent_eventType(const QScxmlEvent* self) { - QScxmlEvent::EventType _ret = self->eventType(); - return static_cast(_ret); -} - -void QScxmlEvent_setEventType(QScxmlEvent* self, int* type) { - self->setEventType((const QScxmlEvent::EventType&)(*type)); -} - -struct miqt_string QScxmlEvent_scxmlType(const QScxmlEvent* self) { - QString _ret = self->scxmlType(); - // 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 QScxmlEvent_sendId(const QScxmlEvent* self) { - QString _ret = self->sendId(); - // 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 QScxmlEvent_setSendId(QScxmlEvent* self, struct miqt_string sendId) { - QString sendId_QString = QString::fromUtf8(sendId.data, sendId.len); - self->setSendId(sendId_QString); -} - -struct miqt_string QScxmlEvent_origin(const QScxmlEvent* self) { - QString _ret = self->origin(); - // 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 QScxmlEvent_setOrigin(QScxmlEvent* self, struct miqt_string origin) { - QString origin_QString = QString::fromUtf8(origin.data, origin.len); - self->setOrigin(origin_QString); -} - -struct miqt_string QScxmlEvent_originType(const QScxmlEvent* self) { - QString _ret = self->originType(); - // 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 QScxmlEvent_setOriginType(QScxmlEvent* self, struct miqt_string originType) { - QString originType_QString = QString::fromUtf8(originType.data, originType.len); - self->setOriginType(originType_QString); -} - -struct miqt_string QScxmlEvent_invokeId(const QScxmlEvent* self) { - QString _ret = self->invokeId(); - // 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 QScxmlEvent_setInvokeId(QScxmlEvent* self, struct miqt_string invokeId) { - QString invokeId_QString = QString::fromUtf8(invokeId.data, invokeId.len); - self->setInvokeId(invokeId_QString); -} - -int QScxmlEvent_delay(const QScxmlEvent* self) { - return self->delay(); -} - -void QScxmlEvent_setDelay(QScxmlEvent* self, int delayInMiliSecs) { - self->setDelay(static_cast(delayInMiliSecs)); -} - -void QScxmlEvent_clear(QScxmlEvent* self) { - self->clear(); -} - -QVariant* QScxmlEvent_data(const QScxmlEvent* self) { - return new QVariant(self->data()); -} - -void QScxmlEvent_setData(QScxmlEvent* self, QVariant* data) { - self->setData(*data); -} - -bool QScxmlEvent_isErrorEvent(const QScxmlEvent* self) { - return self->isErrorEvent(); -} - -struct miqt_string QScxmlEvent_errorMessage(const QScxmlEvent* self) { - QString _ret = self->errorMessage(); - // 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 QScxmlEvent_setErrorMessage(QScxmlEvent* self, struct miqt_string message) { - QString message_QString = QString::fromUtf8(message.data, message.len); - self->setErrorMessage(message_QString); -} - -void QScxmlEvent_delete(QScxmlEvent* self) { - delete self; -} - diff --git a/qt6/scxml/gen_qscxmlevent.go b/qt6/scxml/gen_qscxmlevent.go deleted file mode 100644 index 08c8dc982..000000000 --- a/qt6/scxml/gen_qscxmlevent.go +++ /dev/null @@ -1,216 +0,0 @@ -package scxml - -/* - -#include "gen_qscxmlevent.h" -#include - -*/ -import "C" - -import ( - "github.com/mappu/miqt/qt6" - "runtime" - "unsafe" -) - -type QScxmlEvent__EventType int - -const ( - QScxmlEvent__PlatformEvent QScxmlEvent__EventType = 0 - QScxmlEvent__InternalEvent QScxmlEvent__EventType = 1 - QScxmlEvent__ExternalEvent QScxmlEvent__EventType = 2 -) - -type QScxmlEvent struct { - h *C.QScxmlEvent -} - -func (this *QScxmlEvent) cPointer() *C.QScxmlEvent { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlEvent) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlEvent constructs the type using only CGO pointers. -func newQScxmlEvent(h *C.QScxmlEvent) *QScxmlEvent { - if h == nil { - return nil - } - - return &QScxmlEvent{h: h} -} - -// UnsafeNewQScxmlEvent constructs the type using only unsafe pointers. -func UnsafeNewQScxmlEvent(h unsafe.Pointer) *QScxmlEvent { - return newQScxmlEvent((*C.QScxmlEvent)(h)) -} - -// NewQScxmlEvent constructs a new QScxmlEvent object. -func NewQScxmlEvent() *QScxmlEvent { - - return newQScxmlEvent(C.QScxmlEvent_new()) -} - -// NewQScxmlEvent2 constructs a new QScxmlEvent object. -func NewQScxmlEvent2(other *QScxmlEvent) *QScxmlEvent { - - return newQScxmlEvent(C.QScxmlEvent_new2(other.cPointer())) -} - -func (this *QScxmlEvent) OperatorAssign(other *QScxmlEvent) { - C.QScxmlEvent_operatorAssign(this.h, other.cPointer()) -} - -func (this *QScxmlEvent) Name() string { - var _ms C.struct_miqt_string = C.QScxmlEvent_name(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlEvent) SetName(name string) { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - C.QScxmlEvent_setName(this.h, name_ms) -} - -func (this *QScxmlEvent) EventType() QScxmlEvent__EventType { - return (QScxmlEvent__EventType)(C.QScxmlEvent_eventType(this.h)) -} - -func (this *QScxmlEvent) SetEventType(typeVal *QScxmlEvent__EventType) { - C.QScxmlEvent_setEventType(this.h, (*C.int)(unsafe.Pointer(typeVal))) -} - -func (this *QScxmlEvent) ScxmlType() string { - var _ms C.struct_miqt_string = C.QScxmlEvent_scxmlType(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlEvent) SendId() string { - var _ms C.struct_miqt_string = C.QScxmlEvent_sendId(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlEvent) SetSendId(sendId string) { - sendId_ms := C.struct_miqt_string{} - sendId_ms.data = C.CString(sendId) - sendId_ms.len = C.size_t(len(sendId)) - defer C.free(unsafe.Pointer(sendId_ms.data)) - C.QScxmlEvent_setSendId(this.h, sendId_ms) -} - -func (this *QScxmlEvent) Origin() string { - var _ms C.struct_miqt_string = C.QScxmlEvent_origin(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlEvent) SetOrigin(origin string) { - origin_ms := C.struct_miqt_string{} - origin_ms.data = C.CString(origin) - origin_ms.len = C.size_t(len(origin)) - defer C.free(unsafe.Pointer(origin_ms.data)) - C.QScxmlEvent_setOrigin(this.h, origin_ms) -} - -func (this *QScxmlEvent) OriginType() string { - var _ms C.struct_miqt_string = C.QScxmlEvent_originType(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlEvent) SetOriginType(originType string) { - originType_ms := C.struct_miqt_string{} - originType_ms.data = C.CString(originType) - originType_ms.len = C.size_t(len(originType)) - defer C.free(unsafe.Pointer(originType_ms.data)) - C.QScxmlEvent_setOriginType(this.h, originType_ms) -} - -func (this *QScxmlEvent) InvokeId() string { - var _ms C.struct_miqt_string = C.QScxmlEvent_invokeId(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlEvent) SetInvokeId(invokeId string) { - invokeId_ms := C.struct_miqt_string{} - invokeId_ms.data = C.CString(invokeId) - invokeId_ms.len = C.size_t(len(invokeId)) - defer C.free(unsafe.Pointer(invokeId_ms.data)) - C.QScxmlEvent_setInvokeId(this.h, invokeId_ms) -} - -func (this *QScxmlEvent) Delay() int { - return (int)(C.QScxmlEvent_delay(this.h)) -} - -func (this *QScxmlEvent) SetDelay(delayInMiliSecs int) { - C.QScxmlEvent_setDelay(this.h, (C.int)(delayInMiliSecs)) -} - -func (this *QScxmlEvent) Clear() { - C.QScxmlEvent_clear(this.h) -} - -func (this *QScxmlEvent) Data() *qt6.QVariant { - _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlEvent_data(this.h))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -func (this *QScxmlEvent) SetData(data *qt6.QVariant) { - C.QScxmlEvent_setData(this.h, (*C.QVariant)(data.UnsafePointer())) -} - -func (this *QScxmlEvent) IsErrorEvent() bool { - return (bool)(C.QScxmlEvent_isErrorEvent(this.h)) -} - -func (this *QScxmlEvent) ErrorMessage() string { - var _ms C.struct_miqt_string = C.QScxmlEvent_errorMessage(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlEvent) SetErrorMessage(message string) { - message_ms := C.struct_miqt_string{} - message_ms.data = C.CString(message) - message_ms.len = C.size_t(len(message)) - defer C.free(unsafe.Pointer(message_ms.data)) - C.QScxmlEvent_setErrorMessage(this.h, message_ms) -} - -// Delete this object from C++ memory. -func (this *QScxmlEvent) Delete() { - C.QScxmlEvent_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 *QScxmlEvent) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlEvent) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} diff --git a/qt6/scxml/gen_qscxmlevent.h b/qt6/scxml/gen_qscxmlevent.h deleted file mode 100644 index 9570f2f05..000000000 --- a/qt6/scxml/gen_qscxmlevent.h +++ /dev/null @@ -1,56 +0,0 @@ -#pragma once -#ifndef MIQT_QT6_SCXML_GEN_QSCXMLEVENT_H -#define MIQT_QT6_SCXML_GEN_QSCXMLEVENT_H - -#include -#include -#include - -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - -#include "../../libmiqt/libmiqt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __cplusplus -class QScxmlEvent; -class QVariant; -#else -typedef struct QScxmlEvent QScxmlEvent; -typedef struct QVariant QVariant; -#endif - -QScxmlEvent* QScxmlEvent_new(); -QScxmlEvent* QScxmlEvent_new2(QScxmlEvent* other); -void QScxmlEvent_operatorAssign(QScxmlEvent* self, QScxmlEvent* other); -struct miqt_string QScxmlEvent_name(const QScxmlEvent* self); -void QScxmlEvent_setName(QScxmlEvent* self, struct miqt_string name); -int QScxmlEvent_eventType(const QScxmlEvent* self); -void QScxmlEvent_setEventType(QScxmlEvent* self, int* type); -struct miqt_string QScxmlEvent_scxmlType(const QScxmlEvent* self); -struct miqt_string QScxmlEvent_sendId(const QScxmlEvent* self); -void QScxmlEvent_setSendId(QScxmlEvent* self, struct miqt_string sendId); -struct miqt_string QScxmlEvent_origin(const QScxmlEvent* self); -void QScxmlEvent_setOrigin(QScxmlEvent* self, struct miqt_string origin); -struct miqt_string QScxmlEvent_originType(const QScxmlEvent* self); -void QScxmlEvent_setOriginType(QScxmlEvent* self, struct miqt_string originType); -struct miqt_string QScxmlEvent_invokeId(const QScxmlEvent* self); -void QScxmlEvent_setInvokeId(QScxmlEvent* self, struct miqt_string invokeId); -int QScxmlEvent_delay(const QScxmlEvent* self); -void QScxmlEvent_setDelay(QScxmlEvent* self, int delayInMiliSecs); -void QScxmlEvent_clear(QScxmlEvent* self); -QVariant* QScxmlEvent_data(const QScxmlEvent* self); -void QScxmlEvent_setData(QScxmlEvent* self, QVariant* data); -bool QScxmlEvent_isErrorEvent(const QScxmlEvent* self); -struct miqt_string QScxmlEvent_errorMessage(const QScxmlEvent* self); -void QScxmlEvent_setErrorMessage(QScxmlEvent* self, struct miqt_string message); - -void QScxmlEvent_delete(QScxmlEvent* self); - -#ifdef __cplusplus -} /* extern C */ -#endif - -#endif diff --git a/qt6/scxml/gen_qscxmlexecutablecontent.cpp b/qt6/scxml/gen_qscxmlexecutablecontent.cpp deleted file mode 100644 index 386080b50..000000000 --- a/qt6/scxml/gen_qscxmlexecutablecontent.cpp +++ /dev/null @@ -1,206 +0,0 @@ -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__AssignmentInfo -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__EvaluatorInfo -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ForeachInfo -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__InvokeInfo -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ParameterInfo -#include -#include "gen_qscxmlexecutablecontent.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __cplusplus -} /* extern C */ -#endif - -int QScxmlExecutableContent__EvaluatorInfo_expr(const QScxmlExecutableContent__EvaluatorInfo* self) { - QScxmlExecutableContent::StringId expr_ret = self->expr; - return static_cast(expr_ret); -} - -void QScxmlExecutableContent__EvaluatorInfo_setExpr(QScxmlExecutableContent__EvaluatorInfo* self, int expr) { - self->expr = static_cast(expr); -} - -int QScxmlExecutableContent__EvaluatorInfo_context(const QScxmlExecutableContent__EvaluatorInfo* self) { - QScxmlExecutableContent::StringId context_ret = self->context; - return static_cast(context_ret); -} - -void QScxmlExecutableContent__EvaluatorInfo_setContext(QScxmlExecutableContent__EvaluatorInfo* self, int context) { - self->context = static_cast(context); -} - -void QScxmlExecutableContent__EvaluatorInfo_delete(QScxmlExecutableContent__EvaluatorInfo* self) { - delete self; -} - -int QScxmlExecutableContent__AssignmentInfo_dest(const QScxmlExecutableContent__AssignmentInfo* self) { - QScxmlExecutableContent::StringId dest_ret = self->dest; - return static_cast(dest_ret); -} - -void QScxmlExecutableContent__AssignmentInfo_setDest(QScxmlExecutableContent__AssignmentInfo* self, int dest) { - self->dest = static_cast(dest); -} - -int QScxmlExecutableContent__AssignmentInfo_expr(const QScxmlExecutableContent__AssignmentInfo* self) { - QScxmlExecutableContent::StringId expr_ret = self->expr; - return static_cast(expr_ret); -} - -void QScxmlExecutableContent__AssignmentInfo_setExpr(QScxmlExecutableContent__AssignmentInfo* self, int expr) { - self->expr = static_cast(expr); -} - -int QScxmlExecutableContent__AssignmentInfo_context(const QScxmlExecutableContent__AssignmentInfo* self) { - QScxmlExecutableContent::StringId context_ret = self->context; - return static_cast(context_ret); -} - -void QScxmlExecutableContent__AssignmentInfo_setContext(QScxmlExecutableContent__AssignmentInfo* self, int context) { - self->context = static_cast(context); -} - -void QScxmlExecutableContent__AssignmentInfo_delete(QScxmlExecutableContent__AssignmentInfo* self) { - delete self; -} - -int QScxmlExecutableContent__ForeachInfo_array(const QScxmlExecutableContent__ForeachInfo* self) { - QScxmlExecutableContent::StringId array_ret = self->array; - return static_cast(array_ret); -} - -void QScxmlExecutableContent__ForeachInfo_setArray(QScxmlExecutableContent__ForeachInfo* self, int array) { - self->array = static_cast(array); -} - -int QScxmlExecutableContent__ForeachInfo_item(const QScxmlExecutableContent__ForeachInfo* self) { - QScxmlExecutableContent::StringId item_ret = self->item; - return static_cast(item_ret); -} - -void QScxmlExecutableContent__ForeachInfo_setItem(QScxmlExecutableContent__ForeachInfo* self, int item) { - self->item = static_cast(item); -} - -int QScxmlExecutableContent__ForeachInfo_index(const QScxmlExecutableContent__ForeachInfo* self) { - QScxmlExecutableContent::StringId index_ret = self->index; - return static_cast(index_ret); -} - -void QScxmlExecutableContent__ForeachInfo_setIndex(QScxmlExecutableContent__ForeachInfo* self, int index) { - self->index = static_cast(index); -} - -int QScxmlExecutableContent__ForeachInfo_context(const QScxmlExecutableContent__ForeachInfo* self) { - QScxmlExecutableContent::StringId context_ret = self->context; - return static_cast(context_ret); -} - -void QScxmlExecutableContent__ForeachInfo_setContext(QScxmlExecutableContent__ForeachInfo* self, int context) { - self->context = static_cast(context); -} - -void QScxmlExecutableContent__ForeachInfo_delete(QScxmlExecutableContent__ForeachInfo* self) { - delete self; -} - -int QScxmlExecutableContent__ParameterInfo_name(const QScxmlExecutableContent__ParameterInfo* self) { - QScxmlExecutableContent::StringId name_ret = self->name; - return static_cast(name_ret); -} - -void QScxmlExecutableContent__ParameterInfo_setName(QScxmlExecutableContent__ParameterInfo* self, int name) { - self->name = static_cast(name); -} - -int QScxmlExecutableContent__ParameterInfo_expr(const QScxmlExecutableContent__ParameterInfo* self) { - QScxmlExecutableContent::EvaluatorId expr_ret = self->expr; - return static_cast(expr_ret); -} - -void QScxmlExecutableContent__ParameterInfo_setExpr(QScxmlExecutableContent__ParameterInfo* self, int expr) { - self->expr = static_cast(expr); -} - -int QScxmlExecutableContent__ParameterInfo_location(const QScxmlExecutableContent__ParameterInfo* self) { - QScxmlExecutableContent::StringId location_ret = self->location; - return static_cast(location_ret); -} - -void QScxmlExecutableContent__ParameterInfo_setLocation(QScxmlExecutableContent__ParameterInfo* self, int location) { - self->location = static_cast(location); -} - -void QScxmlExecutableContent__ParameterInfo_delete(QScxmlExecutableContent__ParameterInfo* self) { - delete self; -} - -int QScxmlExecutableContent__InvokeInfo_id(const QScxmlExecutableContent__InvokeInfo* self) { - QScxmlExecutableContent::StringId id_ret = self->id; - return static_cast(id_ret); -} - -void QScxmlExecutableContent__InvokeInfo_setId(QScxmlExecutableContent__InvokeInfo* self, int id) { - self->id = static_cast(id); -} - -int QScxmlExecutableContent__InvokeInfo_prefix(const QScxmlExecutableContent__InvokeInfo* self) { - QScxmlExecutableContent::StringId prefix_ret = self->prefix; - return static_cast(prefix_ret); -} - -void QScxmlExecutableContent__InvokeInfo_setPrefix(QScxmlExecutableContent__InvokeInfo* self, int prefix) { - self->prefix = static_cast(prefix); -} - -int QScxmlExecutableContent__InvokeInfo_location(const QScxmlExecutableContent__InvokeInfo* self) { - QScxmlExecutableContent::StringId location_ret = self->location; - return static_cast(location_ret); -} - -void QScxmlExecutableContent__InvokeInfo_setLocation(QScxmlExecutableContent__InvokeInfo* self, int location) { - self->location = static_cast(location); -} - -int QScxmlExecutableContent__InvokeInfo_context(const QScxmlExecutableContent__InvokeInfo* self) { - QScxmlExecutableContent::StringId context_ret = self->context; - return static_cast(context_ret); -} - -void QScxmlExecutableContent__InvokeInfo_setContext(QScxmlExecutableContent__InvokeInfo* self, int context) { - self->context = static_cast(context); -} - -int QScxmlExecutableContent__InvokeInfo_expr(const QScxmlExecutableContent__InvokeInfo* self) { - QScxmlExecutableContent::EvaluatorId expr_ret = self->expr; - return static_cast(expr_ret); -} - -void QScxmlExecutableContent__InvokeInfo_setExpr(QScxmlExecutableContent__InvokeInfo* self, int expr) { - self->expr = static_cast(expr); -} - -int QScxmlExecutableContent__InvokeInfo_finalize(const QScxmlExecutableContent__InvokeInfo* self) { - QScxmlExecutableContent::ContainerId finalize_ret = self->finalize; - return static_cast(finalize_ret); -} - -void QScxmlExecutableContent__InvokeInfo_setFinalize(QScxmlExecutableContent__InvokeInfo* self, int finalize) { - self->finalize = static_cast(finalize); -} - -bool QScxmlExecutableContent__InvokeInfo_autoforward(const QScxmlExecutableContent__InvokeInfo* self) { - return self->autoforward; -} - -void QScxmlExecutableContent__InvokeInfo_setAutoforward(QScxmlExecutableContent__InvokeInfo* self, bool autoforward) { - self->autoforward = autoforward; -} - -void QScxmlExecutableContent__InvokeInfo_delete(QScxmlExecutableContent__InvokeInfo* self) { - delete self; -} - diff --git a/qt6/scxml/gen_qscxmlexecutablecontent.go b/qt6/scxml/gen_qscxmlexecutablecontent.go deleted file mode 100644 index 72b02f688..000000000 --- a/qt6/scxml/gen_qscxmlexecutablecontent.go +++ /dev/null @@ -1,405 +0,0 @@ -package scxml - -/* - -#include "gen_qscxmlexecutablecontent.h" -#include - -*/ -import "C" - -import ( - "runtime" - "unsafe" -) - -type QScxmlExecutableContent__ int - -const ( - QScxmlExecutableContent__NoContainer QScxmlExecutableContent__ = -1 - QScxmlExecutableContent__NoString QScxmlExecutableContent__ = -1 - QScxmlExecutableContent__NoInstruction QScxmlExecutableContent__ = -1 - QScxmlExecutableContent__NoEvaluator QScxmlExecutableContent__ = -1 -) - -type QScxmlExecutableContent__EvaluatorInfo struct { - h *C.QScxmlExecutableContent__EvaluatorInfo -} - -func (this *QScxmlExecutableContent__EvaluatorInfo) cPointer() *C.QScxmlExecutableContent__EvaluatorInfo { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlExecutableContent__EvaluatorInfo) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlExecutableContent__EvaluatorInfo constructs the type using only CGO pointers. -func newQScxmlExecutableContent__EvaluatorInfo(h *C.QScxmlExecutableContent__EvaluatorInfo) *QScxmlExecutableContent__EvaluatorInfo { - if h == nil { - return nil - } - - return &QScxmlExecutableContent__EvaluatorInfo{h: h} -} - -// UnsafeNewQScxmlExecutableContent__EvaluatorInfo constructs the type using only unsafe pointers. -func UnsafeNewQScxmlExecutableContent__EvaluatorInfo(h unsafe.Pointer) *QScxmlExecutableContent__EvaluatorInfo { - return newQScxmlExecutableContent__EvaluatorInfo((*C.QScxmlExecutableContent__EvaluatorInfo)(h)) -} - -func (this *QScxmlExecutableContent__EvaluatorInfo) Expr() int { - return (int)(C.QScxmlExecutableContent__EvaluatorInfo_expr(this.h)) -} - -func (this *QScxmlExecutableContent__EvaluatorInfo) SetExpr(expr int) { - C.QScxmlExecutableContent__EvaluatorInfo_setExpr(this.h, (C.int)(expr)) -} - -func (this *QScxmlExecutableContent__EvaluatorInfo) Context() int { - return (int)(C.QScxmlExecutableContent__EvaluatorInfo_context(this.h)) -} - -func (this *QScxmlExecutableContent__EvaluatorInfo) SetContext(context int) { - C.QScxmlExecutableContent__EvaluatorInfo_setContext(this.h, (C.int)(context)) -} - -// Delete this object from C++ memory. -func (this *QScxmlExecutableContent__EvaluatorInfo) Delete() { - C.QScxmlExecutableContent__EvaluatorInfo_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 *QScxmlExecutableContent__EvaluatorInfo) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlExecutableContent__EvaluatorInfo) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} - -type QScxmlExecutableContent__AssignmentInfo struct { - h *C.QScxmlExecutableContent__AssignmentInfo -} - -func (this *QScxmlExecutableContent__AssignmentInfo) cPointer() *C.QScxmlExecutableContent__AssignmentInfo { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlExecutableContent__AssignmentInfo) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlExecutableContent__AssignmentInfo constructs the type using only CGO pointers. -func newQScxmlExecutableContent__AssignmentInfo(h *C.QScxmlExecutableContent__AssignmentInfo) *QScxmlExecutableContent__AssignmentInfo { - if h == nil { - return nil - } - - return &QScxmlExecutableContent__AssignmentInfo{h: h} -} - -// UnsafeNewQScxmlExecutableContent__AssignmentInfo constructs the type using only unsafe pointers. -func UnsafeNewQScxmlExecutableContent__AssignmentInfo(h unsafe.Pointer) *QScxmlExecutableContent__AssignmentInfo { - return newQScxmlExecutableContent__AssignmentInfo((*C.QScxmlExecutableContent__AssignmentInfo)(h)) -} - -func (this *QScxmlExecutableContent__AssignmentInfo) Dest() int { - return (int)(C.QScxmlExecutableContent__AssignmentInfo_dest(this.h)) -} - -func (this *QScxmlExecutableContent__AssignmentInfo) SetDest(dest int) { - C.QScxmlExecutableContent__AssignmentInfo_setDest(this.h, (C.int)(dest)) -} - -func (this *QScxmlExecutableContent__AssignmentInfo) Expr() int { - return (int)(C.QScxmlExecutableContent__AssignmentInfo_expr(this.h)) -} - -func (this *QScxmlExecutableContent__AssignmentInfo) SetExpr(expr int) { - C.QScxmlExecutableContent__AssignmentInfo_setExpr(this.h, (C.int)(expr)) -} - -func (this *QScxmlExecutableContent__AssignmentInfo) Context() int { - return (int)(C.QScxmlExecutableContent__AssignmentInfo_context(this.h)) -} - -func (this *QScxmlExecutableContent__AssignmentInfo) SetContext(context int) { - C.QScxmlExecutableContent__AssignmentInfo_setContext(this.h, (C.int)(context)) -} - -// Delete this object from C++ memory. -func (this *QScxmlExecutableContent__AssignmentInfo) Delete() { - C.QScxmlExecutableContent__AssignmentInfo_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 *QScxmlExecutableContent__AssignmentInfo) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlExecutableContent__AssignmentInfo) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} - -type QScxmlExecutableContent__ForeachInfo struct { - h *C.QScxmlExecutableContent__ForeachInfo -} - -func (this *QScxmlExecutableContent__ForeachInfo) cPointer() *C.QScxmlExecutableContent__ForeachInfo { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlExecutableContent__ForeachInfo) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlExecutableContent__ForeachInfo constructs the type using only CGO pointers. -func newQScxmlExecutableContent__ForeachInfo(h *C.QScxmlExecutableContent__ForeachInfo) *QScxmlExecutableContent__ForeachInfo { - if h == nil { - return nil - } - - return &QScxmlExecutableContent__ForeachInfo{h: h} -} - -// UnsafeNewQScxmlExecutableContent__ForeachInfo constructs the type using only unsafe pointers. -func UnsafeNewQScxmlExecutableContent__ForeachInfo(h unsafe.Pointer) *QScxmlExecutableContent__ForeachInfo { - return newQScxmlExecutableContent__ForeachInfo((*C.QScxmlExecutableContent__ForeachInfo)(h)) -} - -func (this *QScxmlExecutableContent__ForeachInfo) Array() int { - return (int)(C.QScxmlExecutableContent__ForeachInfo_array(this.h)) -} - -func (this *QScxmlExecutableContent__ForeachInfo) SetArray(array int) { - C.QScxmlExecutableContent__ForeachInfo_setArray(this.h, (C.int)(array)) -} - -func (this *QScxmlExecutableContent__ForeachInfo) Item() int { - return (int)(C.QScxmlExecutableContent__ForeachInfo_item(this.h)) -} - -func (this *QScxmlExecutableContent__ForeachInfo) SetItem(item int) { - C.QScxmlExecutableContent__ForeachInfo_setItem(this.h, (C.int)(item)) -} - -func (this *QScxmlExecutableContent__ForeachInfo) Index() int { - return (int)(C.QScxmlExecutableContent__ForeachInfo_index(this.h)) -} - -func (this *QScxmlExecutableContent__ForeachInfo) SetIndex(index int) { - C.QScxmlExecutableContent__ForeachInfo_setIndex(this.h, (C.int)(index)) -} - -func (this *QScxmlExecutableContent__ForeachInfo) Context() int { - return (int)(C.QScxmlExecutableContent__ForeachInfo_context(this.h)) -} - -func (this *QScxmlExecutableContent__ForeachInfo) SetContext(context int) { - C.QScxmlExecutableContent__ForeachInfo_setContext(this.h, (C.int)(context)) -} - -// Delete this object from C++ memory. -func (this *QScxmlExecutableContent__ForeachInfo) Delete() { - C.QScxmlExecutableContent__ForeachInfo_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 *QScxmlExecutableContent__ForeachInfo) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlExecutableContent__ForeachInfo) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} - -type QScxmlExecutableContent__ParameterInfo struct { - h *C.QScxmlExecutableContent__ParameterInfo -} - -func (this *QScxmlExecutableContent__ParameterInfo) cPointer() *C.QScxmlExecutableContent__ParameterInfo { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlExecutableContent__ParameterInfo) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlExecutableContent__ParameterInfo constructs the type using only CGO pointers. -func newQScxmlExecutableContent__ParameterInfo(h *C.QScxmlExecutableContent__ParameterInfo) *QScxmlExecutableContent__ParameterInfo { - if h == nil { - return nil - } - - return &QScxmlExecutableContent__ParameterInfo{h: h} -} - -// UnsafeNewQScxmlExecutableContent__ParameterInfo constructs the type using only unsafe pointers. -func UnsafeNewQScxmlExecutableContent__ParameterInfo(h unsafe.Pointer) *QScxmlExecutableContent__ParameterInfo { - return newQScxmlExecutableContent__ParameterInfo((*C.QScxmlExecutableContent__ParameterInfo)(h)) -} - -func (this *QScxmlExecutableContent__ParameterInfo) Name() int { - return (int)(C.QScxmlExecutableContent__ParameterInfo_name(this.h)) -} - -func (this *QScxmlExecutableContent__ParameterInfo) SetName(name int) { - C.QScxmlExecutableContent__ParameterInfo_setName(this.h, (C.int)(name)) -} - -func (this *QScxmlExecutableContent__ParameterInfo) Expr() int { - return (int)(C.QScxmlExecutableContent__ParameterInfo_expr(this.h)) -} - -func (this *QScxmlExecutableContent__ParameterInfo) SetExpr(expr int) { - C.QScxmlExecutableContent__ParameterInfo_setExpr(this.h, (C.int)(expr)) -} - -func (this *QScxmlExecutableContent__ParameterInfo) Location() int { - return (int)(C.QScxmlExecutableContent__ParameterInfo_location(this.h)) -} - -func (this *QScxmlExecutableContent__ParameterInfo) SetLocation(location int) { - C.QScxmlExecutableContent__ParameterInfo_setLocation(this.h, (C.int)(location)) -} - -// Delete this object from C++ memory. -func (this *QScxmlExecutableContent__ParameterInfo) Delete() { - C.QScxmlExecutableContent__ParameterInfo_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 *QScxmlExecutableContent__ParameterInfo) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlExecutableContent__ParameterInfo) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} - -type QScxmlExecutableContent__InvokeInfo struct { - h *C.QScxmlExecutableContent__InvokeInfo -} - -func (this *QScxmlExecutableContent__InvokeInfo) cPointer() *C.QScxmlExecutableContent__InvokeInfo { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlExecutableContent__InvokeInfo) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlExecutableContent__InvokeInfo constructs the type using only CGO pointers. -func newQScxmlExecutableContent__InvokeInfo(h *C.QScxmlExecutableContent__InvokeInfo) *QScxmlExecutableContent__InvokeInfo { - if h == nil { - return nil - } - - return &QScxmlExecutableContent__InvokeInfo{h: h} -} - -// UnsafeNewQScxmlExecutableContent__InvokeInfo constructs the type using only unsafe pointers. -func UnsafeNewQScxmlExecutableContent__InvokeInfo(h unsafe.Pointer) *QScxmlExecutableContent__InvokeInfo { - return newQScxmlExecutableContent__InvokeInfo((*C.QScxmlExecutableContent__InvokeInfo)(h)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) Id() int { - return (int)(C.QScxmlExecutableContent__InvokeInfo_id(this.h)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) SetId(id int) { - C.QScxmlExecutableContent__InvokeInfo_setId(this.h, (C.int)(id)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) Prefix() int { - return (int)(C.QScxmlExecutableContent__InvokeInfo_prefix(this.h)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) SetPrefix(prefix int) { - C.QScxmlExecutableContent__InvokeInfo_setPrefix(this.h, (C.int)(prefix)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) Location() int { - return (int)(C.QScxmlExecutableContent__InvokeInfo_location(this.h)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) SetLocation(location int) { - C.QScxmlExecutableContent__InvokeInfo_setLocation(this.h, (C.int)(location)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) Context() int { - return (int)(C.QScxmlExecutableContent__InvokeInfo_context(this.h)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) SetContext(context int) { - C.QScxmlExecutableContent__InvokeInfo_setContext(this.h, (C.int)(context)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) Expr() int { - return (int)(C.QScxmlExecutableContent__InvokeInfo_expr(this.h)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) SetExpr(expr int) { - C.QScxmlExecutableContent__InvokeInfo_setExpr(this.h, (C.int)(expr)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) Finalize() int { - return (int)(C.QScxmlExecutableContent__InvokeInfo_finalize(this.h)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) SetFinalize(finalize int) { - C.QScxmlExecutableContent__InvokeInfo_setFinalize(this.h, (C.int)(finalize)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) Autoforward() bool { - return (bool)(C.QScxmlExecutableContent__InvokeInfo_autoforward(this.h)) -} - -func (this *QScxmlExecutableContent__InvokeInfo) SetAutoforward(autoforward bool) { - C.QScxmlExecutableContent__InvokeInfo_setAutoforward(this.h, (C.bool)(autoforward)) -} - -// Delete this object from C++ memory. -func (this *QScxmlExecutableContent__InvokeInfo) Delete() { - C.QScxmlExecutableContent__InvokeInfo_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 *QScxmlExecutableContent__InvokeInfo) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlExecutableContent__InvokeInfo) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} diff --git a/qt6/scxml/gen_qscxmlexecutablecontent.h b/qt6/scxml/gen_qscxmlexecutablecontent.h deleted file mode 100644 index 03db72373..000000000 --- a/qt6/scxml/gen_qscxmlexecutablecontent.h +++ /dev/null @@ -1,108 +0,0 @@ -#pragma once -#ifndef MIQT_QT6_SCXML_GEN_QSCXMLEXECUTABLECONTENT_H -#define MIQT_QT6_SCXML_GEN_QSCXMLEXECUTABLECONTENT_H - -#include -#include -#include - -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - -#include "../../libmiqt/libmiqt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __cplusplus -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__AssignmentInfo) -typedef QScxmlExecutableContent::AssignmentInfo QScxmlExecutableContent__AssignmentInfo; -#else -class QScxmlExecutableContent__AssignmentInfo; -#endif -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__EvaluatorInfo) -typedef QScxmlExecutableContent::EvaluatorInfo QScxmlExecutableContent__EvaluatorInfo; -#else -class QScxmlExecutableContent__EvaluatorInfo; -#endif -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ForeachInfo) -typedef QScxmlExecutableContent::ForeachInfo QScxmlExecutableContent__ForeachInfo; -#else -class QScxmlExecutableContent__ForeachInfo; -#endif -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__InvokeInfo) -typedef QScxmlExecutableContent::InvokeInfo QScxmlExecutableContent__InvokeInfo; -#else -class QScxmlExecutableContent__InvokeInfo; -#endif -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ParameterInfo) -typedef QScxmlExecutableContent::ParameterInfo QScxmlExecutableContent__ParameterInfo; -#else -class QScxmlExecutableContent__ParameterInfo; -#endif -#else -typedef struct QScxmlExecutableContent__AssignmentInfo QScxmlExecutableContent__AssignmentInfo; -typedef struct QScxmlExecutableContent__EvaluatorInfo QScxmlExecutableContent__EvaluatorInfo; -typedef struct QScxmlExecutableContent__ForeachInfo QScxmlExecutableContent__ForeachInfo; -typedef struct QScxmlExecutableContent__InvokeInfo QScxmlExecutableContent__InvokeInfo; -typedef struct QScxmlExecutableContent__ParameterInfo QScxmlExecutableContent__ParameterInfo; -#endif - -int QScxmlExecutableContent__EvaluatorInfo_expr(const QScxmlExecutableContent__EvaluatorInfo* self); -void QScxmlExecutableContent__EvaluatorInfo_setExpr(QScxmlExecutableContent__EvaluatorInfo* self, int expr); -int QScxmlExecutableContent__EvaluatorInfo_context(const QScxmlExecutableContent__EvaluatorInfo* self); -void QScxmlExecutableContent__EvaluatorInfo_setContext(QScxmlExecutableContent__EvaluatorInfo* self, int context); - -void QScxmlExecutableContent__EvaluatorInfo_delete(QScxmlExecutableContent__EvaluatorInfo* self); - -int QScxmlExecutableContent__AssignmentInfo_dest(const QScxmlExecutableContent__AssignmentInfo* self); -void QScxmlExecutableContent__AssignmentInfo_setDest(QScxmlExecutableContent__AssignmentInfo* self, int dest); -int QScxmlExecutableContent__AssignmentInfo_expr(const QScxmlExecutableContent__AssignmentInfo* self); -void QScxmlExecutableContent__AssignmentInfo_setExpr(QScxmlExecutableContent__AssignmentInfo* self, int expr); -int QScxmlExecutableContent__AssignmentInfo_context(const QScxmlExecutableContent__AssignmentInfo* self); -void QScxmlExecutableContent__AssignmentInfo_setContext(QScxmlExecutableContent__AssignmentInfo* self, int context); - -void QScxmlExecutableContent__AssignmentInfo_delete(QScxmlExecutableContent__AssignmentInfo* self); - -int QScxmlExecutableContent__ForeachInfo_array(const QScxmlExecutableContent__ForeachInfo* self); -void QScxmlExecutableContent__ForeachInfo_setArray(QScxmlExecutableContent__ForeachInfo* self, int array); -int QScxmlExecutableContent__ForeachInfo_item(const QScxmlExecutableContent__ForeachInfo* self); -void QScxmlExecutableContent__ForeachInfo_setItem(QScxmlExecutableContent__ForeachInfo* self, int item); -int QScxmlExecutableContent__ForeachInfo_index(const QScxmlExecutableContent__ForeachInfo* self); -void QScxmlExecutableContent__ForeachInfo_setIndex(QScxmlExecutableContent__ForeachInfo* self, int index); -int QScxmlExecutableContent__ForeachInfo_context(const QScxmlExecutableContent__ForeachInfo* self); -void QScxmlExecutableContent__ForeachInfo_setContext(QScxmlExecutableContent__ForeachInfo* self, int context); - -void QScxmlExecutableContent__ForeachInfo_delete(QScxmlExecutableContent__ForeachInfo* self); - -int QScxmlExecutableContent__ParameterInfo_name(const QScxmlExecutableContent__ParameterInfo* self); -void QScxmlExecutableContent__ParameterInfo_setName(QScxmlExecutableContent__ParameterInfo* self, int name); -int QScxmlExecutableContent__ParameterInfo_expr(const QScxmlExecutableContent__ParameterInfo* self); -void QScxmlExecutableContent__ParameterInfo_setExpr(QScxmlExecutableContent__ParameterInfo* self, int expr); -int QScxmlExecutableContent__ParameterInfo_location(const QScxmlExecutableContent__ParameterInfo* self); -void QScxmlExecutableContent__ParameterInfo_setLocation(QScxmlExecutableContent__ParameterInfo* self, int location); - -void QScxmlExecutableContent__ParameterInfo_delete(QScxmlExecutableContent__ParameterInfo* self); - -int QScxmlExecutableContent__InvokeInfo_id(const QScxmlExecutableContent__InvokeInfo* self); -void QScxmlExecutableContent__InvokeInfo_setId(QScxmlExecutableContent__InvokeInfo* self, int id); -int QScxmlExecutableContent__InvokeInfo_prefix(const QScxmlExecutableContent__InvokeInfo* self); -void QScxmlExecutableContent__InvokeInfo_setPrefix(QScxmlExecutableContent__InvokeInfo* self, int prefix); -int QScxmlExecutableContent__InvokeInfo_location(const QScxmlExecutableContent__InvokeInfo* self); -void QScxmlExecutableContent__InvokeInfo_setLocation(QScxmlExecutableContent__InvokeInfo* self, int location); -int QScxmlExecutableContent__InvokeInfo_context(const QScxmlExecutableContent__InvokeInfo* self); -void QScxmlExecutableContent__InvokeInfo_setContext(QScxmlExecutableContent__InvokeInfo* self, int context); -int QScxmlExecutableContent__InvokeInfo_expr(const QScxmlExecutableContent__InvokeInfo* self); -void QScxmlExecutableContent__InvokeInfo_setExpr(QScxmlExecutableContent__InvokeInfo* self, int expr); -int QScxmlExecutableContent__InvokeInfo_finalize(const QScxmlExecutableContent__InvokeInfo* self); -void QScxmlExecutableContent__InvokeInfo_setFinalize(QScxmlExecutableContent__InvokeInfo* self, int finalize); -bool QScxmlExecutableContent__InvokeInfo_autoforward(const QScxmlExecutableContent__InvokeInfo* self); -void QScxmlExecutableContent__InvokeInfo_setAutoforward(QScxmlExecutableContent__InvokeInfo* self, bool autoforward); - -void QScxmlExecutableContent__InvokeInfo_delete(QScxmlExecutableContent__InvokeInfo* self); - -#ifdef __cplusplus -} /* extern C */ -#endif - -#endif diff --git a/qt6/scxml/gen_qscxmlinvokableservice.cpp b/qt6/scxml/gen_qscxmlinvokableservice.cpp deleted file mode 100644 index 6afbd27af..000000000 --- a/qt6/scxml/gen_qscxmlinvokableservice.cpp +++ /dev/null @@ -1,1732 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__InvokeInfo -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ParameterInfo -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "gen_qscxmlinvokableservice.h" - -#ifdef __cplusplus -extern "C" { -#endif - -bool miqt_exec_callback_QScxmlInvokableService_start(QScxmlInvokableService*, intptr_t); -struct miqt_string miqt_exec_callback_QScxmlInvokableService_id(const QScxmlInvokableService*, intptr_t); -struct miqt_string miqt_exec_callback_QScxmlInvokableService_name(const QScxmlInvokableService*, intptr_t); -void miqt_exec_callback_QScxmlInvokableService_postEvent(QScxmlInvokableService*, intptr_t, QScxmlEvent*); -bool miqt_exec_callback_QScxmlInvokableService_event(QScxmlInvokableService*, intptr_t, QEvent*); -bool miqt_exec_callback_QScxmlInvokableService_eventFilter(QScxmlInvokableService*, intptr_t, QObject*, QEvent*); -void miqt_exec_callback_QScxmlInvokableService_timerEvent(QScxmlInvokableService*, intptr_t, QTimerEvent*); -void miqt_exec_callback_QScxmlInvokableService_childEvent(QScxmlInvokableService*, intptr_t, QChildEvent*); -void miqt_exec_callback_QScxmlInvokableService_customEvent(QScxmlInvokableService*, intptr_t, QEvent*); -void miqt_exec_callback_QScxmlInvokableService_connectNotify(QScxmlInvokableService*, intptr_t, QMetaMethod*); -void miqt_exec_callback_QScxmlInvokableService_disconnectNotify(QScxmlInvokableService*, intptr_t, QMetaMethod*); -QScxmlInvokableService* miqt_exec_callback_QScxmlInvokableServiceFactory_invoke(QScxmlInvokableServiceFactory*, intptr_t, QScxmlStateMachine*); -bool miqt_exec_callback_QScxmlInvokableServiceFactory_event(QScxmlInvokableServiceFactory*, intptr_t, QEvent*); -bool miqt_exec_callback_QScxmlInvokableServiceFactory_eventFilter(QScxmlInvokableServiceFactory*, intptr_t, QObject*, QEvent*); -void miqt_exec_callback_QScxmlInvokableServiceFactory_timerEvent(QScxmlInvokableServiceFactory*, intptr_t, QTimerEvent*); -void miqt_exec_callback_QScxmlInvokableServiceFactory_childEvent(QScxmlInvokableServiceFactory*, intptr_t, QChildEvent*); -void miqt_exec_callback_QScxmlInvokableServiceFactory_customEvent(QScxmlInvokableServiceFactory*, intptr_t, QEvent*); -void miqt_exec_callback_QScxmlInvokableServiceFactory_connectNotify(QScxmlInvokableServiceFactory*, intptr_t, QMetaMethod*); -void miqt_exec_callback_QScxmlInvokableServiceFactory_disconnectNotify(QScxmlInvokableServiceFactory*, intptr_t, QMetaMethod*); -QScxmlInvokableService* miqt_exec_callback_QScxmlStaticScxmlServiceFactory_invoke(QScxmlStaticScxmlServiceFactory*, intptr_t, QScxmlStateMachine*); -bool miqt_exec_callback_QScxmlStaticScxmlServiceFactory_event(QScxmlStaticScxmlServiceFactory*, intptr_t, QEvent*); -bool miqt_exec_callback_QScxmlStaticScxmlServiceFactory_eventFilter(QScxmlStaticScxmlServiceFactory*, intptr_t, QObject*, QEvent*); -void miqt_exec_callback_QScxmlStaticScxmlServiceFactory_timerEvent(QScxmlStaticScxmlServiceFactory*, intptr_t, QTimerEvent*); -void miqt_exec_callback_QScxmlStaticScxmlServiceFactory_childEvent(QScxmlStaticScxmlServiceFactory*, intptr_t, QChildEvent*); -void miqt_exec_callback_QScxmlStaticScxmlServiceFactory_customEvent(QScxmlStaticScxmlServiceFactory*, intptr_t, QEvent*); -void miqt_exec_callback_QScxmlStaticScxmlServiceFactory_connectNotify(QScxmlStaticScxmlServiceFactory*, intptr_t, QMetaMethod*); -void miqt_exec_callback_QScxmlStaticScxmlServiceFactory_disconnectNotify(QScxmlStaticScxmlServiceFactory*, intptr_t, QMetaMethod*); -QScxmlInvokableService* miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_invoke(QScxmlDynamicScxmlServiceFactory*, intptr_t, QScxmlStateMachine*); -bool miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_event(QScxmlDynamicScxmlServiceFactory*, intptr_t, QEvent*); -bool miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_eventFilter(QScxmlDynamicScxmlServiceFactory*, intptr_t, QObject*, QEvent*); -void miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_timerEvent(QScxmlDynamicScxmlServiceFactory*, intptr_t, QTimerEvent*); -void miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_childEvent(QScxmlDynamicScxmlServiceFactory*, intptr_t, QChildEvent*); -void miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_customEvent(QScxmlDynamicScxmlServiceFactory*, intptr_t, QEvent*); -void miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_connectNotify(QScxmlDynamicScxmlServiceFactory*, intptr_t, QMetaMethod*); -void miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_disconnectNotify(QScxmlDynamicScxmlServiceFactory*, intptr_t, QMetaMethod*); -#ifdef __cplusplus -} /* extern C */ -#endif - -class MiqtVirtualQScxmlInvokableService final : public QScxmlInvokableService { -public: - - MiqtVirtualQScxmlInvokableService(QScxmlStateMachine* parentStateMachine, QScxmlInvokableServiceFactory* parent): QScxmlInvokableService(parentStateMachine, parent) {} - - virtual ~MiqtVirtualQScxmlInvokableService() override = default; - - // cgo.Handle value for overwritten implementation - intptr_t handle__start = 0; - - // Subclass to allow providing a Go implementation - virtual bool start() override { - if (handle__start == 0) { - return false; // Pure virtual, there is no base we can call - } - - bool callback_return_value = miqt_exec_callback_QScxmlInvokableService_start(this, handle__start); - return callback_return_value; - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__id = 0; - - // Subclass to allow providing a Go implementation - virtual QString id() const override { - if (handle__id == 0) { - return QString(); // Pure virtual, there is no base we can call - } - - struct miqt_string callback_return_value = miqt_exec_callback_QScxmlInvokableService_id(this, handle__id); - QString callback_return_value_QString = QString::fromUtf8(callback_return_value.data, callback_return_value.len); - return callback_return_value_QString; - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__name = 0; - - // Subclass to allow providing a Go implementation - virtual QString name() const override { - if (handle__name == 0) { - return QString(); // Pure virtual, there is no base we can call - } - - struct miqt_string callback_return_value = miqt_exec_callback_QScxmlInvokableService_name(this, handle__name); - QString callback_return_value_QString = QString::fromUtf8(callback_return_value.data, callback_return_value.len); - return callback_return_value_QString; - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__postEvent = 0; - - // Subclass to allow providing a Go implementation - virtual void postEvent(QScxmlEvent* event) override { - if (handle__postEvent == 0) { - return; // Pure virtual, there is no base we can call - } - - QScxmlEvent* sigval1 = event; - miqt_exec_callback_QScxmlInvokableService_postEvent(this, handle__postEvent, sigval1); - - } - - // 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 QScxmlInvokableService::event(event); - } - - QEvent* sigval1 = event; - bool callback_return_value = miqt_exec_callback_QScxmlInvokableService_event(this, handle__event, sigval1); - return callback_return_value; - } - - friend bool QScxmlInvokableService_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 QScxmlInvokableService::eventFilter(watched, event); - } - - QObject* sigval1 = watched; - QEvent* sigval2 = event; - bool callback_return_value = miqt_exec_callback_QScxmlInvokableService_eventFilter(this, handle__eventFilter, sigval1, sigval2); - return callback_return_value; - } - - friend bool QScxmlInvokableService_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) { - QScxmlInvokableService::timerEvent(event); - return; - } - - QTimerEvent* sigval1 = event; - miqt_exec_callback_QScxmlInvokableService_timerEvent(this, handle__timerEvent, sigval1); - - } - - friend void QScxmlInvokableService_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) { - QScxmlInvokableService::childEvent(event); - return; - } - - QChildEvent* sigval1 = event; - miqt_exec_callback_QScxmlInvokableService_childEvent(this, handle__childEvent, sigval1); - - } - - friend void QScxmlInvokableService_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) { - QScxmlInvokableService::customEvent(event); - return; - } - - QEvent* sigval1 = event; - miqt_exec_callback_QScxmlInvokableService_customEvent(this, handle__customEvent, sigval1); - - } - - friend void QScxmlInvokableService_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) { - QScxmlInvokableService::connectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlInvokableService_connectNotify(this, handle__connectNotify, sigval1); - - } - - friend void QScxmlInvokableService_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) { - QScxmlInvokableService::disconnectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlInvokableService_disconnectNotify(this, handle__disconnectNotify, sigval1); - - } - - friend void QScxmlInvokableService_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - - // Wrappers to allow calling protected methods: - friend QObject* QScxmlInvokableService_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlInvokableService_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlInvokableService_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); - friend bool QScxmlInvokableService_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); -}; - -QScxmlInvokableService* QScxmlInvokableService_new(QScxmlStateMachine* parentStateMachine, QScxmlInvokableServiceFactory* parent) { - return new (std::nothrow) MiqtVirtualQScxmlInvokableService(parentStateMachine, parent); -} - -void QScxmlInvokableService_virtbase(QScxmlInvokableService* src, QObject** outptr_QObject) { - *outptr_QObject = static_cast(src); -} - -QMetaObject* QScxmlInvokableService_metaObject(const QScxmlInvokableService* self) { - return (QMetaObject*) self->metaObject(); -} - -void* QScxmlInvokableService_metacast(QScxmlInvokableService* self, const char* param1) { - return self->qt_metacast(param1); -} - -struct miqt_string QScxmlInvokableService_tr(const char* s) { - QString _ret = QScxmlInvokableService::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; -} - -QScxmlStateMachine* QScxmlInvokableService_parentStateMachine(const QScxmlInvokableService* self) { - return self->parentStateMachine(); -} - -bool QScxmlInvokableService_start(QScxmlInvokableService* self) { - return self->start(); -} - -struct miqt_string QScxmlInvokableService_id(const QScxmlInvokableService* self) { - QString _ret = self->id(); - // 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 QScxmlInvokableService_name(const QScxmlInvokableService* self) { - QString _ret = self->name(); - // 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 QScxmlInvokableService_postEvent(QScxmlInvokableService* self, QScxmlEvent* event) { - self->postEvent(event); -} - -struct miqt_string QScxmlInvokableService_tr2(const char* s, const char* c) { - QString _ret = QScxmlInvokableService::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 QScxmlInvokableService_tr3(const char* s, const char* c, int n) { - QString _ret = QScxmlInvokableService::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 QScxmlInvokableService_override_virtual_start(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__start = slot; - return true; -} - -bool QScxmlInvokableService_override_virtual_id(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__id = slot; - return true; -} - -bool QScxmlInvokableService_override_virtual_name(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__name = slot; - return true; -} - -bool QScxmlInvokableService_override_virtual_postEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__postEvent = slot; - return true; -} - -bool QScxmlInvokableService_override_virtual_event(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__event = slot; - return true; -} - -bool QScxmlInvokableService_virtualbase_event(void* self, QEvent* event) { - return static_cast(self)->QScxmlInvokableService::event(event); -} - -bool QScxmlInvokableService_override_virtual_eventFilter(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__eventFilter = slot; - return true; -} - -bool QScxmlInvokableService_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { - return static_cast(self)->QScxmlInvokableService::eventFilter(watched, event); -} - -bool QScxmlInvokableService_override_virtual_timerEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__timerEvent = slot; - return true; -} - -void QScxmlInvokableService_virtualbase_timerEvent(void* self, QTimerEvent* event) { - static_cast(self)->QScxmlInvokableService::timerEvent(event); -} - -bool QScxmlInvokableService_override_virtual_childEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__childEvent = slot; - return true; -} - -void QScxmlInvokableService_virtualbase_childEvent(void* self, QChildEvent* event) { - static_cast(self)->QScxmlInvokableService::childEvent(event); -} - -bool QScxmlInvokableService_override_virtual_customEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__customEvent = slot; - return true; -} - -void QScxmlInvokableService_virtualbase_customEvent(void* self, QEvent* event) { - static_cast(self)->QScxmlInvokableService::customEvent(event); -} - -bool QScxmlInvokableService_override_virtual_connectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__connectNotify = slot; - return true; -} - -void QScxmlInvokableService_virtualbase_connectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlInvokableService::connectNotify(*signal); -} - -bool QScxmlInvokableService_override_virtual_disconnectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__disconnectNotify = slot; - return true; -} - -void QScxmlInvokableService_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlInvokableService::disconnectNotify(*signal); -} - -QObject* QScxmlInvokableService_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return nullptr; - } - - *_dynamic_cast_ok = true; - return self_cast->sender(); -} - -int QScxmlInvokableService_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->senderSignalIndex(); -} - -int QScxmlInvokableService_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->receivers(signal); -} - -bool QScxmlInvokableService_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { - MiqtVirtualQScxmlInvokableService* self_cast = dynamic_cast( (QScxmlInvokableService*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return false; - } - - *_dynamic_cast_ok = true; - return self_cast->isSignalConnected(*signal); -} - -void QScxmlInvokableService_delete(QScxmlInvokableService* self) { - delete self; -} - -class MiqtVirtualQScxmlInvokableServiceFactory final : public QScxmlInvokableServiceFactory { -public: - - MiqtVirtualQScxmlInvokableServiceFactory(const QScxmlExecutableContent::InvokeInfo& invokeInfo, const QList& names, const QList& parameters): QScxmlInvokableServiceFactory(invokeInfo, names, parameters) {} - MiqtVirtualQScxmlInvokableServiceFactory(const QScxmlExecutableContent::InvokeInfo& invokeInfo, const QList& names, const QList& parameters, QObject* parent): QScxmlInvokableServiceFactory(invokeInfo, names, parameters, parent) {} - - virtual ~MiqtVirtualQScxmlInvokableServiceFactory() override = default; - - // cgo.Handle value for overwritten implementation - intptr_t handle__invoke = 0; - - // Subclass to allow providing a Go implementation - virtual QScxmlInvokableService* invoke(QScxmlStateMachine* parentStateMachine) override { - if (handle__invoke == 0) { - return nullptr; // Pure virtual, there is no base we can call - } - - QScxmlStateMachine* sigval1 = parentStateMachine; - QScxmlInvokableService* callback_return_value = miqt_exec_callback_QScxmlInvokableServiceFactory_invoke(this, handle__invoke, sigval1); - return callback_return_value; - } - - // 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 QScxmlInvokableServiceFactory::event(event); - } - - QEvent* sigval1 = event; - bool callback_return_value = miqt_exec_callback_QScxmlInvokableServiceFactory_event(this, handle__event, sigval1); - return callback_return_value; - } - - friend bool QScxmlInvokableServiceFactory_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 QScxmlInvokableServiceFactory::eventFilter(watched, event); - } - - QObject* sigval1 = watched; - QEvent* sigval2 = event; - bool callback_return_value = miqt_exec_callback_QScxmlInvokableServiceFactory_eventFilter(this, handle__eventFilter, sigval1, sigval2); - return callback_return_value; - } - - friend bool QScxmlInvokableServiceFactory_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) { - QScxmlInvokableServiceFactory::timerEvent(event); - return; - } - - QTimerEvent* sigval1 = event; - miqt_exec_callback_QScxmlInvokableServiceFactory_timerEvent(this, handle__timerEvent, sigval1); - - } - - friend void QScxmlInvokableServiceFactory_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) { - QScxmlInvokableServiceFactory::childEvent(event); - return; - } - - QChildEvent* sigval1 = event; - miqt_exec_callback_QScxmlInvokableServiceFactory_childEvent(this, handle__childEvent, sigval1); - - } - - friend void QScxmlInvokableServiceFactory_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) { - QScxmlInvokableServiceFactory::customEvent(event); - return; - } - - QEvent* sigval1 = event; - miqt_exec_callback_QScxmlInvokableServiceFactory_customEvent(this, handle__customEvent, sigval1); - - } - - friend void QScxmlInvokableServiceFactory_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) { - QScxmlInvokableServiceFactory::connectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlInvokableServiceFactory_connectNotify(this, handle__connectNotify, sigval1); - - } - - friend void QScxmlInvokableServiceFactory_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) { - QScxmlInvokableServiceFactory::disconnectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlInvokableServiceFactory_disconnectNotify(this, handle__disconnectNotify, sigval1); - - } - - friend void QScxmlInvokableServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - - // Wrappers to allow calling protected methods: - friend QObject* QScxmlInvokableServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlInvokableServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlInvokableServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); - friend bool QScxmlInvokableServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); -}; - -QScxmlInvokableServiceFactory* QScxmlInvokableServiceFactory_new(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters) { - QList names_QList; - names_QList.reserve(names.len); - int* names_arr = static_cast(names.data); - for(size_t i = 0; i < names.len; ++i) { - names_QList.push_back(static_cast(names_arr[i])); - } - QList parameters_QList; - parameters_QList.reserve(parameters.len); - QScxmlExecutableContent__ParameterInfo** parameters_arr = static_cast(parameters.data); - for(size_t i = 0; i < parameters.len; ++i) { - parameters_QList.push_back(*(parameters_arr[i])); - } - return new (std::nothrow) MiqtVirtualQScxmlInvokableServiceFactory(*invokeInfo, names_QList, parameters_QList); -} - -QScxmlInvokableServiceFactory* QScxmlInvokableServiceFactory_new2(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters, QObject* parent) { - QList names_QList; - names_QList.reserve(names.len); - int* names_arr = static_cast(names.data); - for(size_t i = 0; i < names.len; ++i) { - names_QList.push_back(static_cast(names_arr[i])); - } - QList parameters_QList; - parameters_QList.reserve(parameters.len); - QScxmlExecutableContent__ParameterInfo** parameters_arr = static_cast(parameters.data); - for(size_t i = 0; i < parameters.len; ++i) { - parameters_QList.push_back(*(parameters_arr[i])); - } - return new (std::nothrow) MiqtVirtualQScxmlInvokableServiceFactory(*invokeInfo, names_QList, parameters_QList, parent); -} - -void QScxmlInvokableServiceFactory_virtbase(QScxmlInvokableServiceFactory* src, QObject** outptr_QObject) { - *outptr_QObject = static_cast(src); -} - -QMetaObject* QScxmlInvokableServiceFactory_metaObject(const QScxmlInvokableServiceFactory* self) { - return (QMetaObject*) self->metaObject(); -} - -void* QScxmlInvokableServiceFactory_metacast(QScxmlInvokableServiceFactory* self, const char* param1) { - return self->qt_metacast(param1); -} - -struct miqt_string QScxmlInvokableServiceFactory_tr(const char* s) { - QString _ret = QScxmlInvokableServiceFactory::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; -} - -QScxmlInvokableService* QScxmlInvokableServiceFactory_invoke(QScxmlInvokableServiceFactory* self, QScxmlStateMachine* parentStateMachine) { - return self->invoke(parentStateMachine); -} - -QScxmlExecutableContent__InvokeInfo* QScxmlInvokableServiceFactory_invokeInfo(const QScxmlInvokableServiceFactory* self) { - const QScxmlExecutableContent::InvokeInfo& _ret = self->invokeInfo(); - // Cast returned reference into pointer - return const_cast(&_ret); -} - -struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ QScxmlInvokableServiceFactory_parameters(const QScxmlInvokableServiceFactory* self) { - const QList& _ret = self->parameters(); - // Convert QList<> from C++ memory to manually-managed C memory - QScxmlExecutableContent__ParameterInfo** _arr = static_cast(malloc(sizeof(QScxmlExecutableContent__ParameterInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { - _arr[i] = new QScxmlExecutableContent::ParameterInfo(_ret[i]); - } - struct miqt_array _out; - _out.len = _ret.length(); - _out.data = static_cast(_arr); - return _out; -} - -struct miqt_array /* of int */ QScxmlInvokableServiceFactory_names(const QScxmlInvokableServiceFactory* self) { - const QList& _ret = self->names(); - // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { - _arr[i] = _ret[i]; - } - struct miqt_array _out; - _out.len = _ret.length(); - _out.data = static_cast(_arr); - return _out; -} - -struct miqt_string QScxmlInvokableServiceFactory_tr2(const char* s, const char* c) { - QString _ret = QScxmlInvokableServiceFactory::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 QScxmlInvokableServiceFactory_tr3(const char* s, const char* c, int n) { - QString _ret = QScxmlInvokableServiceFactory::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 QScxmlInvokableServiceFactory_override_virtual_invoke(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__invoke = slot; - return true; -} - -bool QScxmlInvokableServiceFactory_override_virtual_event(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__event = slot; - return true; -} - -bool QScxmlInvokableServiceFactory_virtualbase_event(void* self, QEvent* event) { - return static_cast(self)->QScxmlInvokableServiceFactory::event(event); -} - -bool QScxmlInvokableServiceFactory_override_virtual_eventFilter(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__eventFilter = slot; - return true; -} - -bool QScxmlInvokableServiceFactory_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { - return static_cast(self)->QScxmlInvokableServiceFactory::eventFilter(watched, event); -} - -bool QScxmlInvokableServiceFactory_override_virtual_timerEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__timerEvent = slot; - return true; -} - -void QScxmlInvokableServiceFactory_virtualbase_timerEvent(void* self, QTimerEvent* event) { - static_cast(self)->QScxmlInvokableServiceFactory::timerEvent(event); -} - -bool QScxmlInvokableServiceFactory_override_virtual_childEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__childEvent = slot; - return true; -} - -void QScxmlInvokableServiceFactory_virtualbase_childEvent(void* self, QChildEvent* event) { - static_cast(self)->QScxmlInvokableServiceFactory::childEvent(event); -} - -bool QScxmlInvokableServiceFactory_override_virtual_customEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__customEvent = slot; - return true; -} - -void QScxmlInvokableServiceFactory_virtualbase_customEvent(void* self, QEvent* event) { - static_cast(self)->QScxmlInvokableServiceFactory::customEvent(event); -} - -bool QScxmlInvokableServiceFactory_override_virtual_connectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__connectNotify = slot; - return true; -} - -void QScxmlInvokableServiceFactory_virtualbase_connectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlInvokableServiceFactory::connectNotify(*signal); -} - -bool QScxmlInvokableServiceFactory_override_virtual_disconnectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__disconnectNotify = slot; - return true; -} - -void QScxmlInvokableServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlInvokableServiceFactory::disconnectNotify(*signal); -} - -QObject* QScxmlInvokableServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return nullptr; - } - - *_dynamic_cast_ok = true; - return self_cast->sender(); -} - -int QScxmlInvokableServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->senderSignalIndex(); -} - -int QScxmlInvokableServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { - MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->receivers(signal); -} - -bool QScxmlInvokableServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { - MiqtVirtualQScxmlInvokableServiceFactory* self_cast = dynamic_cast( (QScxmlInvokableServiceFactory*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return false; - } - - *_dynamic_cast_ok = true; - return self_cast->isSignalConnected(*signal); -} - -void QScxmlInvokableServiceFactory_delete(QScxmlInvokableServiceFactory* self) { - delete self; -} - -class MiqtVirtualQScxmlStaticScxmlServiceFactory final : public QScxmlStaticScxmlServiceFactory { -public: - - MiqtVirtualQScxmlStaticScxmlServiceFactory(const QMetaObject* metaObject, const QScxmlExecutableContent::InvokeInfo& invokeInfo, const QList& nameList, const QList& parameters): QScxmlStaticScxmlServiceFactory(metaObject, invokeInfo, nameList, parameters) {} - MiqtVirtualQScxmlStaticScxmlServiceFactory(const QMetaObject* metaObject, const QScxmlExecutableContent::InvokeInfo& invokeInfo, const QList& nameList, const QList& parameters, QObject* parent): QScxmlStaticScxmlServiceFactory(metaObject, invokeInfo, nameList, parameters, parent) {} - - virtual ~MiqtVirtualQScxmlStaticScxmlServiceFactory() override = default; - - // cgo.Handle value for overwritten implementation - intptr_t handle__invoke = 0; - - // Subclass to allow providing a Go implementation - virtual QScxmlInvokableService* invoke(QScxmlStateMachine* parentStateMachine) override { - if (handle__invoke == 0) { - return QScxmlStaticScxmlServiceFactory::invoke(parentStateMachine); - } - - QScxmlStateMachine* sigval1 = parentStateMachine; - QScxmlInvokableService* callback_return_value = miqt_exec_callback_QScxmlStaticScxmlServiceFactory_invoke(this, handle__invoke, sigval1); - return callback_return_value; - } - - friend QScxmlInvokableService* QScxmlStaticScxmlServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine); - - // 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 QScxmlStaticScxmlServiceFactory::event(event); - } - - QEvent* sigval1 = event; - bool callback_return_value = miqt_exec_callback_QScxmlStaticScxmlServiceFactory_event(this, handle__event, sigval1); - return callback_return_value; - } - - friend bool QScxmlStaticScxmlServiceFactory_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 QScxmlStaticScxmlServiceFactory::eventFilter(watched, event); - } - - QObject* sigval1 = watched; - QEvent* sigval2 = event; - bool callback_return_value = miqt_exec_callback_QScxmlStaticScxmlServiceFactory_eventFilter(this, handle__eventFilter, sigval1, sigval2); - return callback_return_value; - } - - friend bool QScxmlStaticScxmlServiceFactory_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) { - QScxmlStaticScxmlServiceFactory::timerEvent(event); - return; - } - - QTimerEvent* sigval1 = event; - miqt_exec_callback_QScxmlStaticScxmlServiceFactory_timerEvent(this, handle__timerEvent, sigval1); - - } - - friend void QScxmlStaticScxmlServiceFactory_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) { - QScxmlStaticScxmlServiceFactory::childEvent(event); - return; - } - - QChildEvent* sigval1 = event; - miqt_exec_callback_QScxmlStaticScxmlServiceFactory_childEvent(this, handle__childEvent, sigval1); - - } - - friend void QScxmlStaticScxmlServiceFactory_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) { - QScxmlStaticScxmlServiceFactory::customEvent(event); - return; - } - - QEvent* sigval1 = event; - miqt_exec_callback_QScxmlStaticScxmlServiceFactory_customEvent(this, handle__customEvent, sigval1); - - } - - friend void QScxmlStaticScxmlServiceFactory_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) { - QScxmlStaticScxmlServiceFactory::connectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlStaticScxmlServiceFactory_connectNotify(this, handle__connectNotify, sigval1); - - } - - friend void QScxmlStaticScxmlServiceFactory_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) { - QScxmlStaticScxmlServiceFactory::disconnectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlStaticScxmlServiceFactory_disconnectNotify(this, handle__disconnectNotify, sigval1); - - } - - friend void QScxmlStaticScxmlServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - - // Wrappers to allow calling protected methods: - friend QObject* QScxmlStaticScxmlServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlStaticScxmlServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlStaticScxmlServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); - friend bool QScxmlStaticScxmlServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); -}; - -QScxmlStaticScxmlServiceFactory* QScxmlStaticScxmlServiceFactory_new(QMetaObject* metaObject, QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ nameList, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters) { - QList nameList_QList; - nameList_QList.reserve(nameList.len); - int* nameList_arr = static_cast(nameList.data); - for(size_t i = 0; i < nameList.len; ++i) { - nameList_QList.push_back(static_cast(nameList_arr[i])); - } - QList parameters_QList; - parameters_QList.reserve(parameters.len); - QScxmlExecutableContent__ParameterInfo** parameters_arr = static_cast(parameters.data); - for(size_t i = 0; i < parameters.len; ++i) { - parameters_QList.push_back(*(parameters_arr[i])); - } - return new (std::nothrow) MiqtVirtualQScxmlStaticScxmlServiceFactory(metaObject, *invokeInfo, nameList_QList, parameters_QList); -} - -QScxmlStaticScxmlServiceFactory* QScxmlStaticScxmlServiceFactory_new2(QMetaObject* metaObject, QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ nameList, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters, QObject* parent) { - QList nameList_QList; - nameList_QList.reserve(nameList.len); - int* nameList_arr = static_cast(nameList.data); - for(size_t i = 0; i < nameList.len; ++i) { - nameList_QList.push_back(static_cast(nameList_arr[i])); - } - QList parameters_QList; - parameters_QList.reserve(parameters.len); - QScxmlExecutableContent__ParameterInfo** parameters_arr = static_cast(parameters.data); - for(size_t i = 0; i < parameters.len; ++i) { - parameters_QList.push_back(*(parameters_arr[i])); - } - return new (std::nothrow) MiqtVirtualQScxmlStaticScxmlServiceFactory(metaObject, *invokeInfo, nameList_QList, parameters_QList, parent); -} - -void QScxmlStaticScxmlServiceFactory_virtbase(QScxmlStaticScxmlServiceFactory* src, QScxmlInvokableServiceFactory** outptr_QScxmlInvokableServiceFactory) { - *outptr_QScxmlInvokableServiceFactory = static_cast(src); -} - -QMetaObject* QScxmlStaticScxmlServiceFactory_metaObject(const QScxmlStaticScxmlServiceFactory* self) { - return (QMetaObject*) self->metaObject(); -} - -void* QScxmlStaticScxmlServiceFactory_metacast(QScxmlStaticScxmlServiceFactory* self, const char* param1) { - return self->qt_metacast(param1); -} - -struct miqt_string QScxmlStaticScxmlServiceFactory_tr(const char* s) { - QString _ret = QScxmlStaticScxmlServiceFactory::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; -} - -QScxmlInvokableService* QScxmlStaticScxmlServiceFactory_invoke(QScxmlStaticScxmlServiceFactory* self, QScxmlStateMachine* parentStateMachine) { - return self->invoke(parentStateMachine); -} - -struct miqt_string QScxmlStaticScxmlServiceFactory_tr2(const char* s, const char* c) { - QString _ret = QScxmlStaticScxmlServiceFactory::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 QScxmlStaticScxmlServiceFactory_tr3(const char* s, const char* c, int n) { - QString _ret = QScxmlStaticScxmlServiceFactory::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 QScxmlStaticScxmlServiceFactory_override_virtual_invoke(void* self, intptr_t slot) { - MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__invoke = slot; - return true; -} - -QScxmlInvokableService* QScxmlStaticScxmlServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine) { - return static_cast(self)->QScxmlStaticScxmlServiceFactory::invoke(parentStateMachine); -} - -bool QScxmlStaticScxmlServiceFactory_override_virtual_event(void* self, intptr_t slot) { - MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__event = slot; - return true; -} - -bool QScxmlStaticScxmlServiceFactory_virtualbase_event(void* self, QEvent* event) { - return static_cast(self)->QScxmlStaticScxmlServiceFactory::event(event); -} - -bool QScxmlStaticScxmlServiceFactory_override_virtual_eventFilter(void* self, intptr_t slot) { - MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__eventFilter = slot; - return true; -} - -bool QScxmlStaticScxmlServiceFactory_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { - return static_cast(self)->QScxmlStaticScxmlServiceFactory::eventFilter(watched, event); -} - -bool QScxmlStaticScxmlServiceFactory_override_virtual_timerEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__timerEvent = slot; - return true; -} - -void QScxmlStaticScxmlServiceFactory_virtualbase_timerEvent(void* self, QTimerEvent* event) { - static_cast(self)->QScxmlStaticScxmlServiceFactory::timerEvent(event); -} - -bool QScxmlStaticScxmlServiceFactory_override_virtual_childEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__childEvent = slot; - return true; -} - -void QScxmlStaticScxmlServiceFactory_virtualbase_childEvent(void* self, QChildEvent* event) { - static_cast(self)->QScxmlStaticScxmlServiceFactory::childEvent(event); -} - -bool QScxmlStaticScxmlServiceFactory_override_virtual_customEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__customEvent = slot; - return true; -} - -void QScxmlStaticScxmlServiceFactory_virtualbase_customEvent(void* self, QEvent* event) { - static_cast(self)->QScxmlStaticScxmlServiceFactory::customEvent(event); -} - -bool QScxmlStaticScxmlServiceFactory_override_virtual_connectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__connectNotify = slot; - return true; -} - -void QScxmlStaticScxmlServiceFactory_virtualbase_connectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlStaticScxmlServiceFactory::connectNotify(*signal); -} - -bool QScxmlStaticScxmlServiceFactory_override_virtual_disconnectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__disconnectNotify = slot; - return true; -} - -void QScxmlStaticScxmlServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlStaticScxmlServiceFactory::disconnectNotify(*signal); -} - -QObject* QScxmlStaticScxmlServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return nullptr; - } - - *_dynamic_cast_ok = true; - return self_cast->sender(); -} - -int QScxmlStaticScxmlServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->senderSignalIndex(); -} - -int QScxmlStaticScxmlServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { - MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->receivers(signal); -} - -bool QScxmlStaticScxmlServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { - MiqtVirtualQScxmlStaticScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlStaticScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return false; - } - - *_dynamic_cast_ok = true; - return self_cast->isSignalConnected(*signal); -} - -void QScxmlStaticScxmlServiceFactory_delete(QScxmlStaticScxmlServiceFactory* self) { - delete self; -} - -class MiqtVirtualQScxmlDynamicScxmlServiceFactory final : public QScxmlDynamicScxmlServiceFactory { -public: - - MiqtVirtualQScxmlDynamicScxmlServiceFactory(const QScxmlExecutableContent::InvokeInfo& invokeInfo, const QList& names, const QList& parameters): QScxmlDynamicScxmlServiceFactory(invokeInfo, names, parameters) {} - MiqtVirtualQScxmlDynamicScxmlServiceFactory(const QScxmlExecutableContent::InvokeInfo& invokeInfo, const QList& names, const QList& parameters, QObject* parent): QScxmlDynamicScxmlServiceFactory(invokeInfo, names, parameters, parent) {} - - virtual ~MiqtVirtualQScxmlDynamicScxmlServiceFactory() override = default; - - // cgo.Handle value for overwritten implementation - intptr_t handle__invoke = 0; - - // Subclass to allow providing a Go implementation - virtual QScxmlInvokableService* invoke(QScxmlStateMachine* parentStateMachine) override { - if (handle__invoke == 0) { - return QScxmlDynamicScxmlServiceFactory::invoke(parentStateMachine); - } - - QScxmlStateMachine* sigval1 = parentStateMachine; - QScxmlInvokableService* callback_return_value = miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_invoke(this, handle__invoke, sigval1); - return callback_return_value; - } - - friend QScxmlInvokableService* QScxmlDynamicScxmlServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine); - - // 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 QScxmlDynamicScxmlServiceFactory::event(event); - } - - QEvent* sigval1 = event; - bool callback_return_value = miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_event(this, handle__event, sigval1); - return callback_return_value; - } - - friend bool QScxmlDynamicScxmlServiceFactory_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 QScxmlDynamicScxmlServiceFactory::eventFilter(watched, event); - } - - QObject* sigval1 = watched; - QEvent* sigval2 = event; - bool callback_return_value = miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_eventFilter(this, handle__eventFilter, sigval1, sigval2); - return callback_return_value; - } - - friend bool QScxmlDynamicScxmlServiceFactory_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) { - QScxmlDynamicScxmlServiceFactory::timerEvent(event); - return; - } - - QTimerEvent* sigval1 = event; - miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_timerEvent(this, handle__timerEvent, sigval1); - - } - - friend void QScxmlDynamicScxmlServiceFactory_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) { - QScxmlDynamicScxmlServiceFactory::childEvent(event); - return; - } - - QChildEvent* sigval1 = event; - miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_childEvent(this, handle__childEvent, sigval1); - - } - - friend void QScxmlDynamicScxmlServiceFactory_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) { - QScxmlDynamicScxmlServiceFactory::customEvent(event); - return; - } - - QEvent* sigval1 = event; - miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_customEvent(this, handle__customEvent, sigval1); - - } - - friend void QScxmlDynamicScxmlServiceFactory_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) { - QScxmlDynamicScxmlServiceFactory::connectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_connectNotify(this, handle__connectNotify, sigval1); - - } - - friend void QScxmlDynamicScxmlServiceFactory_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) { - QScxmlDynamicScxmlServiceFactory::disconnectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_disconnectNotify(this, handle__disconnectNotify, sigval1); - - } - - friend void QScxmlDynamicScxmlServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - - // Wrappers to allow calling protected methods: - friend QObject* QScxmlDynamicScxmlServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlDynamicScxmlServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlDynamicScxmlServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); - friend bool QScxmlDynamicScxmlServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); -}; - -QScxmlDynamicScxmlServiceFactory* QScxmlDynamicScxmlServiceFactory_new(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters) { - QList names_QList; - names_QList.reserve(names.len); - int* names_arr = static_cast(names.data); - for(size_t i = 0; i < names.len; ++i) { - names_QList.push_back(static_cast(names_arr[i])); - } - QList parameters_QList; - parameters_QList.reserve(parameters.len); - QScxmlExecutableContent__ParameterInfo** parameters_arr = static_cast(parameters.data); - for(size_t i = 0; i < parameters.len; ++i) { - parameters_QList.push_back(*(parameters_arr[i])); - } - return new (std::nothrow) MiqtVirtualQScxmlDynamicScxmlServiceFactory(*invokeInfo, names_QList, parameters_QList); -} - -QScxmlDynamicScxmlServiceFactory* QScxmlDynamicScxmlServiceFactory_new2(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters, QObject* parent) { - QList names_QList; - names_QList.reserve(names.len); - int* names_arr = static_cast(names.data); - for(size_t i = 0; i < names.len; ++i) { - names_QList.push_back(static_cast(names_arr[i])); - } - QList parameters_QList; - parameters_QList.reserve(parameters.len); - QScxmlExecutableContent__ParameterInfo** parameters_arr = static_cast(parameters.data); - for(size_t i = 0; i < parameters.len; ++i) { - parameters_QList.push_back(*(parameters_arr[i])); - } - return new (std::nothrow) MiqtVirtualQScxmlDynamicScxmlServiceFactory(*invokeInfo, names_QList, parameters_QList, parent); -} - -void QScxmlDynamicScxmlServiceFactory_virtbase(QScxmlDynamicScxmlServiceFactory* src, QScxmlInvokableServiceFactory** outptr_QScxmlInvokableServiceFactory) { - *outptr_QScxmlInvokableServiceFactory = static_cast(src); -} - -QMetaObject* QScxmlDynamicScxmlServiceFactory_metaObject(const QScxmlDynamicScxmlServiceFactory* self) { - return (QMetaObject*) self->metaObject(); -} - -void* QScxmlDynamicScxmlServiceFactory_metacast(QScxmlDynamicScxmlServiceFactory* self, const char* param1) { - return self->qt_metacast(param1); -} - -struct miqt_string QScxmlDynamicScxmlServiceFactory_tr(const char* s) { - QString _ret = QScxmlDynamicScxmlServiceFactory::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; -} - -QScxmlInvokableService* QScxmlDynamicScxmlServiceFactory_invoke(QScxmlDynamicScxmlServiceFactory* self, QScxmlStateMachine* parentStateMachine) { - return self->invoke(parentStateMachine); -} - -struct miqt_string QScxmlDynamicScxmlServiceFactory_tr2(const char* s, const char* c) { - QString _ret = QScxmlDynamicScxmlServiceFactory::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 QScxmlDynamicScxmlServiceFactory_tr3(const char* s, const char* c, int n) { - QString _ret = QScxmlDynamicScxmlServiceFactory::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 QScxmlDynamicScxmlServiceFactory_override_virtual_invoke(void* self, intptr_t slot) { - MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__invoke = slot; - return true; -} - -QScxmlInvokableService* QScxmlDynamicScxmlServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine) { - return static_cast(self)->QScxmlDynamicScxmlServiceFactory::invoke(parentStateMachine); -} - -bool QScxmlDynamicScxmlServiceFactory_override_virtual_event(void* self, intptr_t slot) { - MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__event = slot; - return true; -} - -bool QScxmlDynamicScxmlServiceFactory_virtualbase_event(void* self, QEvent* event) { - return static_cast(self)->QScxmlDynamicScxmlServiceFactory::event(event); -} - -bool QScxmlDynamicScxmlServiceFactory_override_virtual_eventFilter(void* self, intptr_t slot) { - MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__eventFilter = slot; - return true; -} - -bool QScxmlDynamicScxmlServiceFactory_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { - return static_cast(self)->QScxmlDynamicScxmlServiceFactory::eventFilter(watched, event); -} - -bool QScxmlDynamicScxmlServiceFactory_override_virtual_timerEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__timerEvent = slot; - return true; -} - -void QScxmlDynamicScxmlServiceFactory_virtualbase_timerEvent(void* self, QTimerEvent* event) { - static_cast(self)->QScxmlDynamicScxmlServiceFactory::timerEvent(event); -} - -bool QScxmlDynamicScxmlServiceFactory_override_virtual_childEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__childEvent = slot; - return true; -} - -void QScxmlDynamicScxmlServiceFactory_virtualbase_childEvent(void* self, QChildEvent* event) { - static_cast(self)->QScxmlDynamicScxmlServiceFactory::childEvent(event); -} - -bool QScxmlDynamicScxmlServiceFactory_override_virtual_customEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__customEvent = slot; - return true; -} - -void QScxmlDynamicScxmlServiceFactory_virtualbase_customEvent(void* self, QEvent* event) { - static_cast(self)->QScxmlDynamicScxmlServiceFactory::customEvent(event); -} - -bool QScxmlDynamicScxmlServiceFactory_override_virtual_connectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__connectNotify = slot; - return true; -} - -void QScxmlDynamicScxmlServiceFactory_virtualbase_connectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlDynamicScxmlServiceFactory::connectNotify(*signal); -} - -bool QScxmlDynamicScxmlServiceFactory_override_virtual_disconnectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__disconnectNotify = slot; - return true; -} - -void QScxmlDynamicScxmlServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlDynamicScxmlServiceFactory::disconnectNotify(*signal); -} - -QObject* QScxmlDynamicScxmlServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return nullptr; - } - - *_dynamic_cast_ok = true; - return self_cast->sender(); -} - -int QScxmlDynamicScxmlServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->senderSignalIndex(); -} - -int QScxmlDynamicScxmlServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { - MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->receivers(signal); -} - -bool QScxmlDynamicScxmlServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { - MiqtVirtualQScxmlDynamicScxmlServiceFactory* self_cast = dynamic_cast( (QScxmlDynamicScxmlServiceFactory*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return false; - } - - *_dynamic_cast_ok = true; - return self_cast->isSignalConnected(*signal); -} - -void QScxmlDynamicScxmlServiceFactory_delete(QScxmlDynamicScxmlServiceFactory* self) { - delete self; -} - diff --git a/qt6/scxml/gen_qscxmlinvokableservice.go b/qt6/scxml/gen_qscxmlinvokableservice.go deleted file mode 100644 index 7d5e69cc1..000000000 --- a/qt6/scxml/gen_qscxmlinvokableservice.go +++ /dev/null @@ -1,1705 +0,0 @@ -package scxml - -/* - -#include "gen_qscxmlinvokableservice.h" -#include - -*/ -import "C" - -import ( - "github.com/mappu/miqt/qt6" - "runtime" - "runtime/cgo" - "unsafe" -) - -type QScxmlInvokableService struct { - h *C.QScxmlInvokableService - *qt6.QObject -} - -func (this *QScxmlInvokableService) cPointer() *C.QScxmlInvokableService { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlInvokableService) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlInvokableService constructs the type using only CGO pointers. -func newQScxmlInvokableService(h *C.QScxmlInvokableService) *QScxmlInvokableService { - if h == nil { - return nil - } - var outptr_QObject *C.QObject = nil - C.QScxmlInvokableService_virtbase(h, &outptr_QObject) - - return &QScxmlInvokableService{h: h, - QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} -} - -// UnsafeNewQScxmlInvokableService constructs the type using only unsafe pointers. -func UnsafeNewQScxmlInvokableService(h unsafe.Pointer) *QScxmlInvokableService { - return newQScxmlInvokableService((*C.QScxmlInvokableService)(h)) -} - -// NewQScxmlInvokableService constructs a new QScxmlInvokableService object. -func NewQScxmlInvokableService(parentStateMachine *QScxmlStateMachine, parent *QScxmlInvokableServiceFactory) *QScxmlInvokableService { - - return newQScxmlInvokableService(C.QScxmlInvokableService_new(parentStateMachine.cPointer(), parent.cPointer())) -} - -func (this *QScxmlInvokableService) MetaObject() *qt6.QMetaObject { - return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlInvokableService_metaObject(this.h))) -} - -func (this *QScxmlInvokableService) Metacast(param1 string) unsafe.Pointer { - param1_Cstring := C.CString(param1) - defer C.free(unsafe.Pointer(param1_Cstring)) - return (unsafe.Pointer)(C.QScxmlInvokableService_metacast(this.h, param1_Cstring)) -} - -func QScxmlInvokableService_Tr(s string) string { - s_Cstring := C.CString(s) - defer C.free(unsafe.Pointer(s_Cstring)) - var _ms C.struct_miqt_string = C.QScxmlInvokableService_tr(s_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlInvokableService) ParentStateMachine() *QScxmlStateMachine { - return newQScxmlStateMachine(C.QScxmlInvokableService_parentStateMachine(this.h)) -} - -func (this *QScxmlInvokableService) Start() bool { - return (bool)(C.QScxmlInvokableService_start(this.h)) -} - -func (this *QScxmlInvokableService) Id() string { - var _ms C.struct_miqt_string = C.QScxmlInvokableService_id(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlInvokableService) Name() string { - var _ms C.struct_miqt_string = C.QScxmlInvokableService_name(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlInvokableService) PostEvent(event *QScxmlEvent) { - C.QScxmlInvokableService_postEvent(this.h, event.cPointer()) -} - -func QScxmlInvokableService_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.QScxmlInvokableService_tr2(s_Cstring, c_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func QScxmlInvokableService_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.QScxmlInvokableService_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 -} - -// Sender can only be called from a QScxmlInvokableService that was directly constructed. -func (this *QScxmlInvokableService) Sender() *qt6.QObject { - - var _dynamic_cast_ok C.bool = false - _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlInvokableService_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 QScxmlInvokableService that was directly constructed. -func (this *QScxmlInvokableService) SenderSignalIndex() int { - - var _dynamic_cast_ok C.bool = false - _method_ret := (int)(C.QScxmlInvokableService_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 QScxmlInvokableService that was directly constructed. -func (this *QScxmlInvokableService) 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.QScxmlInvokableService_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 QScxmlInvokableService that was directly constructed. -func (this *QScxmlInvokableService) IsSignalConnected(signal *qt6.QMetaMethod) bool { - - var _dynamic_cast_ok C.bool = false - _method_ret := (bool)(C.QScxmlInvokableService_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 *QScxmlInvokableService) OnStart(slot func() bool) { - ok := C.QScxmlInvokableService_override_virtual_start(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlInvokableService_start -func miqt_exec_callback_QScxmlInvokableService_start(self *C.QScxmlInvokableService, cb C.intptr_t) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func() bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - virtualReturn := gofunc() - - return (C.bool)(virtualReturn) - -} -func (this *QScxmlInvokableService) OnId(slot func() string) { - ok := C.QScxmlInvokableService_override_virtual_id(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlInvokableService_id -func miqt_exec_callback_QScxmlInvokableService_id(self *C.QScxmlInvokableService, cb C.intptr_t) C.struct_miqt_string { - gofunc, ok := cgo.Handle(cb).Value().(func() string) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - virtualReturn := gofunc() - virtualReturn_ms := C.struct_miqt_string{} - virtualReturn_ms.data = C.CString(virtualReturn) - virtualReturn_ms.len = C.size_t(len(virtualReturn)) - defer C.free(unsafe.Pointer(virtualReturn_ms.data)) - - return virtualReturn_ms - -} -func (this *QScxmlInvokableService) OnName(slot func() string) { - ok := C.QScxmlInvokableService_override_virtual_name(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlInvokableService_name -func miqt_exec_callback_QScxmlInvokableService_name(self *C.QScxmlInvokableService, cb C.intptr_t) C.struct_miqt_string { - gofunc, ok := cgo.Handle(cb).Value().(func() string) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - virtualReturn := gofunc() - virtualReturn_ms := C.struct_miqt_string{} - virtualReturn_ms.data = C.CString(virtualReturn) - virtualReturn_ms.len = C.size_t(len(virtualReturn)) - defer C.free(unsafe.Pointer(virtualReturn_ms.data)) - - return virtualReturn_ms - -} -func (this *QScxmlInvokableService) OnPostEvent(slot func(event *QScxmlEvent)) { - ok := C.QScxmlInvokableService_override_virtual_postEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlInvokableService_postEvent -func miqt_exec_callback_QScxmlInvokableService_postEvent(self *C.QScxmlInvokableService, cb C.intptr_t, event *C.QScxmlEvent) { - gofunc, ok := cgo.Handle(cb).Value().(func(event *QScxmlEvent)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQScxmlEvent(event) - - gofunc(slotval1) - -} - -func (this *QScxmlInvokableService) callVirtualBase_Event(event *qt6.QEvent) bool { - - return (bool)(C.QScxmlInvokableService_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlInvokableService) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { - ok := C.QScxmlInvokableService_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_QScxmlInvokableService_event -func miqt_exec_callback_QScxmlInvokableService_event(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_Event, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlInvokableService) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { - - return (bool)(C.QScxmlInvokableService_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlInvokableService) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { - ok := C.QScxmlInvokableService_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_QScxmlInvokableService_eventFilter -func miqt_exec_callback_QScxmlInvokableService_eventFilter(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlInvokableService) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { - - C.QScxmlInvokableService_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) - -} -func (this *QScxmlInvokableService) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { - ok := C.QScxmlInvokableService_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_QScxmlInvokableService_timerEvent -func miqt_exec_callback_QScxmlInvokableService_timerEvent(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_TimerEvent, slotval1) - -} - -func (this *QScxmlInvokableService) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { - - C.QScxmlInvokableService_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) - -} -func (this *QScxmlInvokableService) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { - ok := C.QScxmlInvokableService_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_QScxmlInvokableService_childEvent -func miqt_exec_callback_QScxmlInvokableService_childEvent(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_ChildEvent, slotval1) - -} - -func (this *QScxmlInvokableService) callVirtualBase_CustomEvent(event *qt6.QEvent) { - - C.QScxmlInvokableService_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) - -} -func (this *QScxmlInvokableService) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { - ok := C.QScxmlInvokableService_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_QScxmlInvokableService_customEvent -func miqt_exec_callback_QScxmlInvokableService_customEvent(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_CustomEvent, slotval1) - -} - -func (this *QScxmlInvokableService) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlInvokableService_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlInvokableService) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlInvokableService_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_QScxmlInvokableService_connectNotify -func miqt_exec_callback_QScxmlInvokableService_connectNotify(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_ConnectNotify, slotval1) - -} - -func (this *QScxmlInvokableService) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlInvokableService_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlInvokableService) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlInvokableService_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_QScxmlInvokableService_disconnectNotify -func miqt_exec_callback_QScxmlInvokableService_disconnectNotify(self *C.QScxmlInvokableService, 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((&QScxmlInvokableService{h: self}).callVirtualBase_DisconnectNotify, slotval1) - -} - -// Delete this object from C++ memory. -func (this *QScxmlInvokableService) Delete() { - C.QScxmlInvokableService_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 *QScxmlInvokableService) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlInvokableService) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} - -type QScxmlInvokableServiceFactory struct { - h *C.QScxmlInvokableServiceFactory - *qt6.QObject -} - -func (this *QScxmlInvokableServiceFactory) cPointer() *C.QScxmlInvokableServiceFactory { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlInvokableServiceFactory) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlInvokableServiceFactory constructs the type using only CGO pointers. -func newQScxmlInvokableServiceFactory(h *C.QScxmlInvokableServiceFactory) *QScxmlInvokableServiceFactory { - if h == nil { - return nil - } - var outptr_QObject *C.QObject = nil - C.QScxmlInvokableServiceFactory_virtbase(h, &outptr_QObject) - - return &QScxmlInvokableServiceFactory{h: h, - QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} -} - -// UnsafeNewQScxmlInvokableServiceFactory constructs the type using only unsafe pointers. -func UnsafeNewQScxmlInvokableServiceFactory(h unsafe.Pointer) *QScxmlInvokableServiceFactory { - return newQScxmlInvokableServiceFactory((*C.QScxmlInvokableServiceFactory)(h)) -} - -// NewQScxmlInvokableServiceFactory constructs a new QScxmlInvokableServiceFactory object. -func NewQScxmlInvokableServiceFactory(invokeInfo *QScxmlExecutableContent__InvokeInfo, names []int, parameters []QScxmlExecutableContent__ParameterInfo) *QScxmlInvokableServiceFactory { - names_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(names)))) - defer C.free(unsafe.Pointer(names_CArray)) - for i := range names { - names_CArray[i] = (C.int)(names[i]) - } - names_ma := C.struct_miqt_array{len: C.size_t(len(names)), data: unsafe.Pointer(names_CArray)} - parameters_CArray := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(C.malloc(C.size_t(8 * len(parameters)))) - defer C.free(unsafe.Pointer(parameters_CArray)) - for i := range parameters { - parameters_CArray[i] = parameters[i].cPointer() - } - parameters_ma := C.struct_miqt_array{len: C.size_t(len(parameters)), data: unsafe.Pointer(parameters_CArray)} - - return newQScxmlInvokableServiceFactory(C.QScxmlInvokableServiceFactory_new(invokeInfo.cPointer(), names_ma, parameters_ma)) -} - -// NewQScxmlInvokableServiceFactory2 constructs a new QScxmlInvokableServiceFactory object. -func NewQScxmlInvokableServiceFactory2(invokeInfo *QScxmlExecutableContent__InvokeInfo, names []int, parameters []QScxmlExecutableContent__ParameterInfo, parent *qt6.QObject) *QScxmlInvokableServiceFactory { - names_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(names)))) - defer C.free(unsafe.Pointer(names_CArray)) - for i := range names { - names_CArray[i] = (C.int)(names[i]) - } - names_ma := C.struct_miqt_array{len: C.size_t(len(names)), data: unsafe.Pointer(names_CArray)} - parameters_CArray := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(C.malloc(C.size_t(8 * len(parameters)))) - defer C.free(unsafe.Pointer(parameters_CArray)) - for i := range parameters { - parameters_CArray[i] = parameters[i].cPointer() - } - parameters_ma := C.struct_miqt_array{len: C.size_t(len(parameters)), data: unsafe.Pointer(parameters_CArray)} - - return newQScxmlInvokableServiceFactory(C.QScxmlInvokableServiceFactory_new2(invokeInfo.cPointer(), names_ma, parameters_ma, (*C.QObject)(parent.UnsafePointer()))) -} - -func (this *QScxmlInvokableServiceFactory) MetaObject() *qt6.QMetaObject { - return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlInvokableServiceFactory_metaObject(this.h))) -} - -func (this *QScxmlInvokableServiceFactory) Metacast(param1 string) unsafe.Pointer { - param1_Cstring := C.CString(param1) - defer C.free(unsafe.Pointer(param1_Cstring)) - return (unsafe.Pointer)(C.QScxmlInvokableServiceFactory_metacast(this.h, param1_Cstring)) -} - -func QScxmlInvokableServiceFactory_Tr(s string) string { - s_Cstring := C.CString(s) - defer C.free(unsafe.Pointer(s_Cstring)) - var _ms C.struct_miqt_string = C.QScxmlInvokableServiceFactory_tr(s_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlInvokableServiceFactory) Invoke(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService { - return newQScxmlInvokableService(C.QScxmlInvokableServiceFactory_invoke(this.h, parentStateMachine.cPointer())) -} - -func (this *QScxmlInvokableServiceFactory) InvokeInfo() *QScxmlExecutableContent__InvokeInfo { - return newQScxmlExecutableContent__InvokeInfo(C.QScxmlInvokableServiceFactory_invokeInfo(this.h)) -} - -func (this *QScxmlInvokableServiceFactory) Parameters() []QScxmlExecutableContent__ParameterInfo { - var _ma C.struct_miqt_array = C.QScxmlInvokableServiceFactory_parameters(this.h) - _ret := make([]QScxmlExecutableContent__ParameterInfo, int(_ma.len)) - _outCast := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(unsafe.Pointer(_ma.data)) // hey ya - for i := 0; i < int(_ma.len); i++ { - _lv_goptr := newQScxmlExecutableContent__ParameterInfo(_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 *QScxmlInvokableServiceFactory) Names() []int { - var _ma C.struct_miqt_array = C.QScxmlInvokableServiceFactory_names(this.h) - _ret := make([]int, int(_ma.len)) - _outCast := (*[0xffff]C.int)(unsafe.Pointer(_ma.data)) // hey ya - for i := 0; i < int(_ma.len); i++ { - _ret[i] = (int)(_outCast[i]) - } - return _ret -} - -func QScxmlInvokableServiceFactory_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.QScxmlInvokableServiceFactory_tr2(s_Cstring, c_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func QScxmlInvokableServiceFactory_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.QScxmlInvokableServiceFactory_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 -} - -// Sender can only be called from a QScxmlInvokableServiceFactory that was directly constructed. -func (this *QScxmlInvokableServiceFactory) Sender() *qt6.QObject { - - var _dynamic_cast_ok C.bool = false - _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlInvokableServiceFactory_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 QScxmlInvokableServiceFactory that was directly constructed. -func (this *QScxmlInvokableServiceFactory) SenderSignalIndex() int { - - var _dynamic_cast_ok C.bool = false - _method_ret := (int)(C.QScxmlInvokableServiceFactory_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 QScxmlInvokableServiceFactory that was directly constructed. -func (this *QScxmlInvokableServiceFactory) 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.QScxmlInvokableServiceFactory_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 QScxmlInvokableServiceFactory that was directly constructed. -func (this *QScxmlInvokableServiceFactory) IsSignalConnected(signal *qt6.QMetaMethod) bool { - - var _dynamic_cast_ok C.bool = false - _method_ret := (bool)(C.QScxmlInvokableServiceFactory_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 *QScxmlInvokableServiceFactory) OnInvoke(slot func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) { - ok := C.QScxmlInvokableServiceFactory_override_virtual_invoke(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlInvokableServiceFactory_invoke -func miqt_exec_callback_QScxmlInvokableServiceFactory_invoke(self *C.QScxmlInvokableServiceFactory, cb C.intptr_t, parentStateMachine *C.QScxmlStateMachine) *C.QScxmlInvokableService { - gofunc, ok := cgo.Handle(cb).Value().(func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQScxmlStateMachine(parentStateMachine) - - virtualReturn := gofunc(slotval1) - - return virtualReturn.cPointer() - -} - -func (this *QScxmlInvokableServiceFactory) callVirtualBase_Event(event *qt6.QEvent) bool { - - return (bool)(C.QScxmlInvokableServiceFactory_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlInvokableServiceFactory) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { - ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_event -func miqt_exec_callback_QScxmlInvokableServiceFactory_event(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_Event, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlInvokableServiceFactory) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { - - return (bool)(C.QScxmlInvokableServiceFactory_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlInvokableServiceFactory) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { - ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_eventFilter -func miqt_exec_callback_QScxmlInvokableServiceFactory_eventFilter(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlInvokableServiceFactory) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { - - C.QScxmlInvokableServiceFactory_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) - -} -func (this *QScxmlInvokableServiceFactory) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { - ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_timerEvent -func miqt_exec_callback_QScxmlInvokableServiceFactory_timerEvent(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_TimerEvent, slotval1) - -} - -func (this *QScxmlInvokableServiceFactory) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { - - C.QScxmlInvokableServiceFactory_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) - -} -func (this *QScxmlInvokableServiceFactory) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { - ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_childEvent -func miqt_exec_callback_QScxmlInvokableServiceFactory_childEvent(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_ChildEvent, slotval1) - -} - -func (this *QScxmlInvokableServiceFactory) callVirtualBase_CustomEvent(event *qt6.QEvent) { - - C.QScxmlInvokableServiceFactory_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) - -} -func (this *QScxmlInvokableServiceFactory) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { - ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_customEvent -func miqt_exec_callback_QScxmlInvokableServiceFactory_customEvent(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_CustomEvent, slotval1) - -} - -func (this *QScxmlInvokableServiceFactory) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlInvokableServiceFactory_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlInvokableServiceFactory) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_connectNotify -func miqt_exec_callback_QScxmlInvokableServiceFactory_connectNotify(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_ConnectNotify, slotval1) - -} - -func (this *QScxmlInvokableServiceFactory) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlInvokableServiceFactory_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlInvokableServiceFactory) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlInvokableServiceFactory_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_QScxmlInvokableServiceFactory_disconnectNotify -func miqt_exec_callback_QScxmlInvokableServiceFactory_disconnectNotify(self *C.QScxmlInvokableServiceFactory, 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((&QScxmlInvokableServiceFactory{h: self}).callVirtualBase_DisconnectNotify, slotval1) - -} - -// Delete this object from C++ memory. -func (this *QScxmlInvokableServiceFactory) Delete() { - C.QScxmlInvokableServiceFactory_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 *QScxmlInvokableServiceFactory) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlInvokableServiceFactory) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} - -type QScxmlStaticScxmlServiceFactory struct { - h *C.QScxmlStaticScxmlServiceFactory - *QScxmlInvokableServiceFactory -} - -func (this *QScxmlStaticScxmlServiceFactory) cPointer() *C.QScxmlStaticScxmlServiceFactory { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlStaticScxmlServiceFactory) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlStaticScxmlServiceFactory constructs the type using only CGO pointers. -func newQScxmlStaticScxmlServiceFactory(h *C.QScxmlStaticScxmlServiceFactory) *QScxmlStaticScxmlServiceFactory { - if h == nil { - return nil - } - var outptr_QScxmlInvokableServiceFactory *C.QScxmlInvokableServiceFactory = nil - C.QScxmlStaticScxmlServiceFactory_virtbase(h, &outptr_QScxmlInvokableServiceFactory) - - return &QScxmlStaticScxmlServiceFactory{h: h, - QScxmlInvokableServiceFactory: newQScxmlInvokableServiceFactory(outptr_QScxmlInvokableServiceFactory)} -} - -// UnsafeNewQScxmlStaticScxmlServiceFactory constructs the type using only unsafe pointers. -func UnsafeNewQScxmlStaticScxmlServiceFactory(h unsafe.Pointer) *QScxmlStaticScxmlServiceFactory { - return newQScxmlStaticScxmlServiceFactory((*C.QScxmlStaticScxmlServiceFactory)(h)) -} - -// NewQScxmlStaticScxmlServiceFactory constructs a new QScxmlStaticScxmlServiceFactory object. -func NewQScxmlStaticScxmlServiceFactory(metaObject *qt6.QMetaObject, invokeInfo *QScxmlExecutableContent__InvokeInfo, nameList []int, parameters []QScxmlExecutableContent__ParameterInfo) *QScxmlStaticScxmlServiceFactory { - nameList_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(nameList)))) - defer C.free(unsafe.Pointer(nameList_CArray)) - for i := range nameList { - nameList_CArray[i] = (C.int)(nameList[i]) - } - nameList_ma := C.struct_miqt_array{len: C.size_t(len(nameList)), data: unsafe.Pointer(nameList_CArray)} - parameters_CArray := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(C.malloc(C.size_t(8 * len(parameters)))) - defer C.free(unsafe.Pointer(parameters_CArray)) - for i := range parameters { - parameters_CArray[i] = parameters[i].cPointer() - } - parameters_ma := C.struct_miqt_array{len: C.size_t(len(parameters)), data: unsafe.Pointer(parameters_CArray)} - - return newQScxmlStaticScxmlServiceFactory(C.QScxmlStaticScxmlServiceFactory_new((*C.QMetaObject)(metaObject.UnsafePointer()), invokeInfo.cPointer(), nameList_ma, parameters_ma)) -} - -// NewQScxmlStaticScxmlServiceFactory2 constructs a new QScxmlStaticScxmlServiceFactory object. -func NewQScxmlStaticScxmlServiceFactory2(metaObject *qt6.QMetaObject, invokeInfo *QScxmlExecutableContent__InvokeInfo, nameList []int, parameters []QScxmlExecutableContent__ParameterInfo, parent *qt6.QObject) *QScxmlStaticScxmlServiceFactory { - nameList_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(nameList)))) - defer C.free(unsafe.Pointer(nameList_CArray)) - for i := range nameList { - nameList_CArray[i] = (C.int)(nameList[i]) - } - nameList_ma := C.struct_miqt_array{len: C.size_t(len(nameList)), data: unsafe.Pointer(nameList_CArray)} - parameters_CArray := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(C.malloc(C.size_t(8 * len(parameters)))) - defer C.free(unsafe.Pointer(parameters_CArray)) - for i := range parameters { - parameters_CArray[i] = parameters[i].cPointer() - } - parameters_ma := C.struct_miqt_array{len: C.size_t(len(parameters)), data: unsafe.Pointer(parameters_CArray)} - - return newQScxmlStaticScxmlServiceFactory(C.QScxmlStaticScxmlServiceFactory_new2((*C.QMetaObject)(metaObject.UnsafePointer()), invokeInfo.cPointer(), nameList_ma, parameters_ma, (*C.QObject)(parent.UnsafePointer()))) -} - -func (this *QScxmlStaticScxmlServiceFactory) MetaObject() *qt6.QMetaObject { - return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlStaticScxmlServiceFactory_metaObject(this.h))) -} - -func (this *QScxmlStaticScxmlServiceFactory) Metacast(param1 string) unsafe.Pointer { - param1_Cstring := C.CString(param1) - defer C.free(unsafe.Pointer(param1_Cstring)) - return (unsafe.Pointer)(C.QScxmlStaticScxmlServiceFactory_metacast(this.h, param1_Cstring)) -} - -func QScxmlStaticScxmlServiceFactory_Tr(s string) string { - s_Cstring := C.CString(s) - defer C.free(unsafe.Pointer(s_Cstring)) - var _ms C.struct_miqt_string = C.QScxmlStaticScxmlServiceFactory_tr(s_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlStaticScxmlServiceFactory) Invoke(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService { - return newQScxmlInvokableService(C.QScxmlStaticScxmlServiceFactory_invoke(this.h, parentStateMachine.cPointer())) -} - -func QScxmlStaticScxmlServiceFactory_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.QScxmlStaticScxmlServiceFactory_tr2(s_Cstring, c_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func QScxmlStaticScxmlServiceFactory_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.QScxmlStaticScxmlServiceFactory_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 -} - -// Sender can only be called from a QScxmlStaticScxmlServiceFactory that was directly constructed. -func (this *QScxmlStaticScxmlServiceFactory) Sender() *qt6.QObject { - - var _dynamic_cast_ok C.bool = false - _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlStaticScxmlServiceFactory_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 QScxmlStaticScxmlServiceFactory that was directly constructed. -func (this *QScxmlStaticScxmlServiceFactory) SenderSignalIndex() int { - - var _dynamic_cast_ok C.bool = false - _method_ret := (int)(C.QScxmlStaticScxmlServiceFactory_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 QScxmlStaticScxmlServiceFactory that was directly constructed. -func (this *QScxmlStaticScxmlServiceFactory) 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.QScxmlStaticScxmlServiceFactory_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 QScxmlStaticScxmlServiceFactory that was directly constructed. -func (this *QScxmlStaticScxmlServiceFactory) IsSignalConnected(signal *qt6.QMetaMethod) bool { - - var _dynamic_cast_ok C.bool = false - _method_ret := (bool)(C.QScxmlStaticScxmlServiceFactory_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 *QScxmlStaticScxmlServiceFactory) callVirtualBase_Invoke(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService { - - return newQScxmlInvokableService(C.QScxmlStaticScxmlServiceFactory_virtualbase_invoke(unsafe.Pointer(this.h), parentStateMachine.cPointer())) - -} -func (this *QScxmlStaticScxmlServiceFactory) OnInvoke(slot func(super func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService, parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) { - ok := C.QScxmlStaticScxmlServiceFactory_override_virtual_invoke(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlStaticScxmlServiceFactory_invoke -func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_invoke(self *C.QScxmlStaticScxmlServiceFactory, cb C.intptr_t, parentStateMachine *C.QScxmlStateMachine) *C.QScxmlInvokableService { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService, parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQScxmlStateMachine(parentStateMachine) - - virtualReturn := gofunc((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_Invoke, slotval1) - - return virtualReturn.cPointer() - -} - -func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_Event(event *qt6.QEvent) bool { - - return (bool)(C.QScxmlStaticScxmlServiceFactory_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlStaticScxmlServiceFactory) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { - ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_event -func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_event(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_Event, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { - - return (bool)(C.QScxmlStaticScxmlServiceFactory_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlStaticScxmlServiceFactory) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { - ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_eventFilter -func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_eventFilter(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { - - C.QScxmlStaticScxmlServiceFactory_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) - -} -func (this *QScxmlStaticScxmlServiceFactory) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { - ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_timerEvent -func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_timerEvent(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_TimerEvent, slotval1) - -} - -func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { - - C.QScxmlStaticScxmlServiceFactory_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) - -} -func (this *QScxmlStaticScxmlServiceFactory) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { - ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_childEvent -func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_childEvent(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_ChildEvent, slotval1) - -} - -func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_CustomEvent(event *qt6.QEvent) { - - C.QScxmlStaticScxmlServiceFactory_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) - -} -func (this *QScxmlStaticScxmlServiceFactory) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { - ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_customEvent -func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_customEvent(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_CustomEvent, slotval1) - -} - -func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlStaticScxmlServiceFactory_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlStaticScxmlServiceFactory) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_connectNotify -func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_connectNotify(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_ConnectNotify, slotval1) - -} - -func (this *QScxmlStaticScxmlServiceFactory) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlStaticScxmlServiceFactory_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlStaticScxmlServiceFactory) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlStaticScxmlServiceFactory_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_QScxmlStaticScxmlServiceFactory_disconnectNotify -func miqt_exec_callback_QScxmlStaticScxmlServiceFactory_disconnectNotify(self *C.QScxmlStaticScxmlServiceFactory, 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((&QScxmlStaticScxmlServiceFactory{h: self}).callVirtualBase_DisconnectNotify, slotval1) - -} - -// Delete this object from C++ memory. -func (this *QScxmlStaticScxmlServiceFactory) Delete() { - C.QScxmlStaticScxmlServiceFactory_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 *QScxmlStaticScxmlServiceFactory) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlStaticScxmlServiceFactory) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} - -type QScxmlDynamicScxmlServiceFactory struct { - h *C.QScxmlDynamicScxmlServiceFactory - *QScxmlInvokableServiceFactory -} - -func (this *QScxmlDynamicScxmlServiceFactory) cPointer() *C.QScxmlDynamicScxmlServiceFactory { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlDynamicScxmlServiceFactory) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlDynamicScxmlServiceFactory constructs the type using only CGO pointers. -func newQScxmlDynamicScxmlServiceFactory(h *C.QScxmlDynamicScxmlServiceFactory) *QScxmlDynamicScxmlServiceFactory { - if h == nil { - return nil - } - var outptr_QScxmlInvokableServiceFactory *C.QScxmlInvokableServiceFactory = nil - C.QScxmlDynamicScxmlServiceFactory_virtbase(h, &outptr_QScxmlInvokableServiceFactory) - - return &QScxmlDynamicScxmlServiceFactory{h: h, - QScxmlInvokableServiceFactory: newQScxmlInvokableServiceFactory(outptr_QScxmlInvokableServiceFactory)} -} - -// UnsafeNewQScxmlDynamicScxmlServiceFactory constructs the type using only unsafe pointers. -func UnsafeNewQScxmlDynamicScxmlServiceFactory(h unsafe.Pointer) *QScxmlDynamicScxmlServiceFactory { - return newQScxmlDynamicScxmlServiceFactory((*C.QScxmlDynamicScxmlServiceFactory)(h)) -} - -// NewQScxmlDynamicScxmlServiceFactory constructs a new QScxmlDynamicScxmlServiceFactory object. -func NewQScxmlDynamicScxmlServiceFactory(invokeInfo *QScxmlExecutableContent__InvokeInfo, names []int, parameters []QScxmlExecutableContent__ParameterInfo) *QScxmlDynamicScxmlServiceFactory { - names_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(names)))) - defer C.free(unsafe.Pointer(names_CArray)) - for i := range names { - names_CArray[i] = (C.int)(names[i]) - } - names_ma := C.struct_miqt_array{len: C.size_t(len(names)), data: unsafe.Pointer(names_CArray)} - parameters_CArray := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(C.malloc(C.size_t(8 * len(parameters)))) - defer C.free(unsafe.Pointer(parameters_CArray)) - for i := range parameters { - parameters_CArray[i] = parameters[i].cPointer() - } - parameters_ma := C.struct_miqt_array{len: C.size_t(len(parameters)), data: unsafe.Pointer(parameters_CArray)} - - return newQScxmlDynamicScxmlServiceFactory(C.QScxmlDynamicScxmlServiceFactory_new(invokeInfo.cPointer(), names_ma, parameters_ma)) -} - -// NewQScxmlDynamicScxmlServiceFactory2 constructs a new QScxmlDynamicScxmlServiceFactory object. -func NewQScxmlDynamicScxmlServiceFactory2(invokeInfo *QScxmlExecutableContent__InvokeInfo, names []int, parameters []QScxmlExecutableContent__ParameterInfo, parent *qt6.QObject) *QScxmlDynamicScxmlServiceFactory { - names_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(names)))) - defer C.free(unsafe.Pointer(names_CArray)) - for i := range names { - names_CArray[i] = (C.int)(names[i]) - } - names_ma := C.struct_miqt_array{len: C.size_t(len(names)), data: unsafe.Pointer(names_CArray)} - parameters_CArray := (*[0xffff]*C.QScxmlExecutableContent__ParameterInfo)(C.malloc(C.size_t(8 * len(parameters)))) - defer C.free(unsafe.Pointer(parameters_CArray)) - for i := range parameters { - parameters_CArray[i] = parameters[i].cPointer() - } - parameters_ma := C.struct_miqt_array{len: C.size_t(len(parameters)), data: unsafe.Pointer(parameters_CArray)} - - return newQScxmlDynamicScxmlServiceFactory(C.QScxmlDynamicScxmlServiceFactory_new2(invokeInfo.cPointer(), names_ma, parameters_ma, (*C.QObject)(parent.UnsafePointer()))) -} - -func (this *QScxmlDynamicScxmlServiceFactory) MetaObject() *qt6.QMetaObject { - return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlDynamicScxmlServiceFactory_metaObject(this.h))) -} - -func (this *QScxmlDynamicScxmlServiceFactory) Metacast(param1 string) unsafe.Pointer { - param1_Cstring := C.CString(param1) - defer C.free(unsafe.Pointer(param1_Cstring)) - return (unsafe.Pointer)(C.QScxmlDynamicScxmlServiceFactory_metacast(this.h, param1_Cstring)) -} - -func QScxmlDynamicScxmlServiceFactory_Tr(s string) string { - s_Cstring := C.CString(s) - defer C.free(unsafe.Pointer(s_Cstring)) - var _ms C.struct_miqt_string = C.QScxmlDynamicScxmlServiceFactory_tr(s_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlDynamicScxmlServiceFactory) Invoke(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService { - return newQScxmlInvokableService(C.QScxmlDynamicScxmlServiceFactory_invoke(this.h, parentStateMachine.cPointer())) -} - -func QScxmlDynamicScxmlServiceFactory_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.QScxmlDynamicScxmlServiceFactory_tr2(s_Cstring, c_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func QScxmlDynamicScxmlServiceFactory_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.QScxmlDynamicScxmlServiceFactory_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 -} - -// Sender can only be called from a QScxmlDynamicScxmlServiceFactory that was directly constructed. -func (this *QScxmlDynamicScxmlServiceFactory) Sender() *qt6.QObject { - - var _dynamic_cast_ok C.bool = false - _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlDynamicScxmlServiceFactory_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 QScxmlDynamicScxmlServiceFactory that was directly constructed. -func (this *QScxmlDynamicScxmlServiceFactory) SenderSignalIndex() int { - - var _dynamic_cast_ok C.bool = false - _method_ret := (int)(C.QScxmlDynamicScxmlServiceFactory_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 QScxmlDynamicScxmlServiceFactory that was directly constructed. -func (this *QScxmlDynamicScxmlServiceFactory) 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.QScxmlDynamicScxmlServiceFactory_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 QScxmlDynamicScxmlServiceFactory that was directly constructed. -func (this *QScxmlDynamicScxmlServiceFactory) IsSignalConnected(signal *qt6.QMetaMethod) bool { - - var _dynamic_cast_ok C.bool = false - _method_ret := (bool)(C.QScxmlDynamicScxmlServiceFactory_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 *QScxmlDynamicScxmlServiceFactory) callVirtualBase_Invoke(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService { - - return newQScxmlInvokableService(C.QScxmlDynamicScxmlServiceFactory_virtualbase_invoke(unsafe.Pointer(this.h), parentStateMachine.cPointer())) - -} -func (this *QScxmlDynamicScxmlServiceFactory) OnInvoke(slot func(super func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService, parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) { - ok := C.QScxmlDynamicScxmlServiceFactory_override_virtual_invoke(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_invoke -func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_invoke(self *C.QScxmlDynamicScxmlServiceFactory, cb C.intptr_t, parentStateMachine *C.QScxmlStateMachine) *C.QScxmlInvokableService { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService, parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQScxmlStateMachine(parentStateMachine) - - virtualReturn := gofunc((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_Invoke, slotval1) - - return virtualReturn.cPointer() - -} - -func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_Event(event *qt6.QEvent) bool { - - return (bool)(C.QScxmlDynamicScxmlServiceFactory_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlDynamicScxmlServiceFactory) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { - ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_event -func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_event(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_Event, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { - - return (bool)(C.QScxmlDynamicScxmlServiceFactory_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlDynamicScxmlServiceFactory) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { - ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_eventFilter -func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_eventFilter(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { - - C.QScxmlDynamicScxmlServiceFactory_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) - -} -func (this *QScxmlDynamicScxmlServiceFactory) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { - ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_timerEvent -func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_timerEvent(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_TimerEvent, slotval1) - -} - -func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { - - C.QScxmlDynamicScxmlServiceFactory_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) - -} -func (this *QScxmlDynamicScxmlServiceFactory) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { - ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_childEvent -func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_childEvent(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_ChildEvent, slotval1) - -} - -func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_CustomEvent(event *qt6.QEvent) { - - C.QScxmlDynamicScxmlServiceFactory_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) - -} -func (this *QScxmlDynamicScxmlServiceFactory) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { - ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_customEvent -func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_customEvent(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_CustomEvent, slotval1) - -} - -func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlDynamicScxmlServiceFactory_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlDynamicScxmlServiceFactory) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_connectNotify -func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_connectNotify(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_ConnectNotify, slotval1) - -} - -func (this *QScxmlDynamicScxmlServiceFactory) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlDynamicScxmlServiceFactory_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlDynamicScxmlServiceFactory) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlDynamicScxmlServiceFactory_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_QScxmlDynamicScxmlServiceFactory_disconnectNotify -func miqt_exec_callback_QScxmlDynamicScxmlServiceFactory_disconnectNotify(self *C.QScxmlDynamicScxmlServiceFactory, 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((&QScxmlDynamicScxmlServiceFactory{h: self}).callVirtualBase_DisconnectNotify, slotval1) - -} - -// Delete this object from C++ memory. -func (this *QScxmlDynamicScxmlServiceFactory) Delete() { - C.QScxmlDynamicScxmlServiceFactory_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 *QScxmlDynamicScxmlServiceFactory) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlDynamicScxmlServiceFactory) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} diff --git a/qt6/scxml/gen_qscxmlinvokableservice.h b/qt6/scxml/gen_qscxmlinvokableservice.h deleted file mode 100644 index 7500783e7..000000000 --- a/qt6/scxml/gen_qscxmlinvokableservice.h +++ /dev/null @@ -1,209 +0,0 @@ -#pragma once -#ifndef MIQT_QT6_SCXML_GEN_QSCXMLINVOKABLESERVICE_H -#define MIQT_QT6_SCXML_GEN_QSCXMLINVOKABLESERVICE_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 QScxmlDynamicScxmlServiceFactory; -class QScxmlEvent; -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__InvokeInfo) -typedef QScxmlExecutableContent::InvokeInfo QScxmlExecutableContent__InvokeInfo; -#else -class QScxmlExecutableContent__InvokeInfo; -#endif -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ParameterInfo) -typedef QScxmlExecutableContent::ParameterInfo QScxmlExecutableContent__ParameterInfo; -#else -class QScxmlExecutableContent__ParameterInfo; -#endif -class QScxmlInvokableService; -class QScxmlInvokableServiceFactory; -class QScxmlStateMachine; -class QScxmlStaticScxmlServiceFactory; -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 QScxmlDynamicScxmlServiceFactory QScxmlDynamicScxmlServiceFactory; -typedef struct QScxmlEvent QScxmlEvent; -typedef struct QScxmlExecutableContent__InvokeInfo QScxmlExecutableContent__InvokeInfo; -typedef struct QScxmlExecutableContent__ParameterInfo QScxmlExecutableContent__ParameterInfo; -typedef struct QScxmlInvokableService QScxmlInvokableService; -typedef struct QScxmlInvokableServiceFactory QScxmlInvokableServiceFactory; -typedef struct QScxmlStateMachine QScxmlStateMachine; -typedef struct QScxmlStaticScxmlServiceFactory QScxmlStaticScxmlServiceFactory; -typedef struct QTimerEvent QTimerEvent; -#endif - -QScxmlInvokableService* QScxmlInvokableService_new(QScxmlStateMachine* parentStateMachine, QScxmlInvokableServiceFactory* parent); -void QScxmlInvokableService_virtbase(QScxmlInvokableService* src, QObject** outptr_QObject); -QMetaObject* QScxmlInvokableService_metaObject(const QScxmlInvokableService* self); -void* QScxmlInvokableService_metacast(QScxmlInvokableService* self, const char* param1); -struct miqt_string QScxmlInvokableService_tr(const char* s); -QScxmlStateMachine* QScxmlInvokableService_parentStateMachine(const QScxmlInvokableService* self); -bool QScxmlInvokableService_start(QScxmlInvokableService* self); -struct miqt_string QScxmlInvokableService_id(const QScxmlInvokableService* self); -struct miqt_string QScxmlInvokableService_name(const QScxmlInvokableService* self); -void QScxmlInvokableService_postEvent(QScxmlInvokableService* self, QScxmlEvent* event); -struct miqt_string QScxmlInvokableService_tr2(const char* s, const char* c); -struct miqt_string QScxmlInvokableService_tr3(const char* s, const char* c, int n); - -bool QScxmlInvokableService_override_virtual_start(void* self, intptr_t slot); -bool QScxmlInvokableService_virtualbase_start(void* self); -bool QScxmlInvokableService_override_virtual_id(void* self, intptr_t slot); -struct miqt_string QScxmlInvokableService_virtualbase_id(const void* self); -bool QScxmlInvokableService_override_virtual_name(void* self, intptr_t slot); -struct miqt_string QScxmlInvokableService_virtualbase_name(const void* self); -bool QScxmlInvokableService_override_virtual_postEvent(void* self, intptr_t slot); -void QScxmlInvokableService_virtualbase_postEvent(void* self, QScxmlEvent* event); -bool QScxmlInvokableService_override_virtual_event(void* self, intptr_t slot); -bool QScxmlInvokableService_virtualbase_event(void* self, QEvent* event); -bool QScxmlInvokableService_override_virtual_eventFilter(void* self, intptr_t slot); -bool QScxmlInvokableService_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); -bool QScxmlInvokableService_override_virtual_timerEvent(void* self, intptr_t slot); -void QScxmlInvokableService_virtualbase_timerEvent(void* self, QTimerEvent* event); -bool QScxmlInvokableService_override_virtual_childEvent(void* self, intptr_t slot); -void QScxmlInvokableService_virtualbase_childEvent(void* self, QChildEvent* event); -bool QScxmlInvokableService_override_virtual_customEvent(void* self, intptr_t slot); -void QScxmlInvokableService_virtualbase_customEvent(void* self, QEvent* event); -bool QScxmlInvokableService_override_virtual_connectNotify(void* self, intptr_t slot); -void QScxmlInvokableService_virtualbase_connectNotify(void* self, QMetaMethod* signal); -bool QScxmlInvokableService_override_virtual_disconnectNotify(void* self, intptr_t slot); -void QScxmlInvokableService_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - -QObject* QScxmlInvokableService_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); -int QScxmlInvokableService_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); -int QScxmlInvokableService_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); -bool QScxmlInvokableService_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); - -void QScxmlInvokableService_delete(QScxmlInvokableService* self); - -QScxmlInvokableServiceFactory* QScxmlInvokableServiceFactory_new(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters); -QScxmlInvokableServiceFactory* QScxmlInvokableServiceFactory_new2(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters, QObject* parent); -void QScxmlInvokableServiceFactory_virtbase(QScxmlInvokableServiceFactory* src, QObject** outptr_QObject); -QMetaObject* QScxmlInvokableServiceFactory_metaObject(const QScxmlInvokableServiceFactory* self); -void* QScxmlInvokableServiceFactory_metacast(QScxmlInvokableServiceFactory* self, const char* param1); -struct miqt_string QScxmlInvokableServiceFactory_tr(const char* s); -QScxmlInvokableService* QScxmlInvokableServiceFactory_invoke(QScxmlInvokableServiceFactory* self, QScxmlStateMachine* parentStateMachine); -QScxmlExecutableContent__InvokeInfo* QScxmlInvokableServiceFactory_invokeInfo(const QScxmlInvokableServiceFactory* self); -struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ QScxmlInvokableServiceFactory_parameters(const QScxmlInvokableServiceFactory* self); -struct miqt_array /* of int */ QScxmlInvokableServiceFactory_names(const QScxmlInvokableServiceFactory* self); -struct miqt_string QScxmlInvokableServiceFactory_tr2(const char* s, const char* c); -struct miqt_string QScxmlInvokableServiceFactory_tr3(const char* s, const char* c, int n); - -bool QScxmlInvokableServiceFactory_override_virtual_invoke(void* self, intptr_t slot); -QScxmlInvokableService* QScxmlInvokableServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine); -bool QScxmlInvokableServiceFactory_override_virtual_event(void* self, intptr_t slot); -bool QScxmlInvokableServiceFactory_virtualbase_event(void* self, QEvent* event); -bool QScxmlInvokableServiceFactory_override_virtual_eventFilter(void* self, intptr_t slot); -bool QScxmlInvokableServiceFactory_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); -bool QScxmlInvokableServiceFactory_override_virtual_timerEvent(void* self, intptr_t slot); -void QScxmlInvokableServiceFactory_virtualbase_timerEvent(void* self, QTimerEvent* event); -bool QScxmlInvokableServiceFactory_override_virtual_childEvent(void* self, intptr_t slot); -void QScxmlInvokableServiceFactory_virtualbase_childEvent(void* self, QChildEvent* event); -bool QScxmlInvokableServiceFactory_override_virtual_customEvent(void* self, intptr_t slot); -void QScxmlInvokableServiceFactory_virtualbase_customEvent(void* self, QEvent* event); -bool QScxmlInvokableServiceFactory_override_virtual_connectNotify(void* self, intptr_t slot); -void QScxmlInvokableServiceFactory_virtualbase_connectNotify(void* self, QMetaMethod* signal); -bool QScxmlInvokableServiceFactory_override_virtual_disconnectNotify(void* self, intptr_t slot); -void QScxmlInvokableServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - -QObject* QScxmlInvokableServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); -int QScxmlInvokableServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); -int QScxmlInvokableServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); -bool QScxmlInvokableServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); - -void QScxmlInvokableServiceFactory_delete(QScxmlInvokableServiceFactory* self); - -QScxmlStaticScxmlServiceFactory* QScxmlStaticScxmlServiceFactory_new(QMetaObject* metaObject, QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ nameList, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters); -QScxmlStaticScxmlServiceFactory* QScxmlStaticScxmlServiceFactory_new2(QMetaObject* metaObject, QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ nameList, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters, QObject* parent); -void QScxmlStaticScxmlServiceFactory_virtbase(QScxmlStaticScxmlServiceFactory* src, QScxmlInvokableServiceFactory** outptr_QScxmlInvokableServiceFactory); -QMetaObject* QScxmlStaticScxmlServiceFactory_metaObject(const QScxmlStaticScxmlServiceFactory* self); -void* QScxmlStaticScxmlServiceFactory_metacast(QScxmlStaticScxmlServiceFactory* self, const char* param1); -struct miqt_string QScxmlStaticScxmlServiceFactory_tr(const char* s); -QScxmlInvokableService* QScxmlStaticScxmlServiceFactory_invoke(QScxmlStaticScxmlServiceFactory* self, QScxmlStateMachine* parentStateMachine); -struct miqt_string QScxmlStaticScxmlServiceFactory_tr2(const char* s, const char* c); -struct miqt_string QScxmlStaticScxmlServiceFactory_tr3(const char* s, const char* c, int n); - -bool QScxmlStaticScxmlServiceFactory_override_virtual_invoke(void* self, intptr_t slot); -QScxmlInvokableService* QScxmlStaticScxmlServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine); -bool QScxmlStaticScxmlServiceFactory_override_virtual_event(void* self, intptr_t slot); -bool QScxmlStaticScxmlServiceFactory_virtualbase_event(void* self, QEvent* event); -bool QScxmlStaticScxmlServiceFactory_override_virtual_eventFilter(void* self, intptr_t slot); -bool QScxmlStaticScxmlServiceFactory_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); -bool QScxmlStaticScxmlServiceFactory_override_virtual_timerEvent(void* self, intptr_t slot); -void QScxmlStaticScxmlServiceFactory_virtualbase_timerEvent(void* self, QTimerEvent* event); -bool QScxmlStaticScxmlServiceFactory_override_virtual_childEvent(void* self, intptr_t slot); -void QScxmlStaticScxmlServiceFactory_virtualbase_childEvent(void* self, QChildEvent* event); -bool QScxmlStaticScxmlServiceFactory_override_virtual_customEvent(void* self, intptr_t slot); -void QScxmlStaticScxmlServiceFactory_virtualbase_customEvent(void* self, QEvent* event); -bool QScxmlStaticScxmlServiceFactory_override_virtual_connectNotify(void* self, intptr_t slot); -void QScxmlStaticScxmlServiceFactory_virtualbase_connectNotify(void* self, QMetaMethod* signal); -bool QScxmlStaticScxmlServiceFactory_override_virtual_disconnectNotify(void* self, intptr_t slot); -void QScxmlStaticScxmlServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - -QObject* QScxmlStaticScxmlServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); -int QScxmlStaticScxmlServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); -int QScxmlStaticScxmlServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); -bool QScxmlStaticScxmlServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); - -void QScxmlStaticScxmlServiceFactory_delete(QScxmlStaticScxmlServiceFactory* self); - -QScxmlDynamicScxmlServiceFactory* QScxmlDynamicScxmlServiceFactory_new(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters); -QScxmlDynamicScxmlServiceFactory* QScxmlDynamicScxmlServiceFactory_new2(QScxmlExecutableContent__InvokeInfo* invokeInfo, struct miqt_array /* of int */ names, struct miqt_array /* of QScxmlExecutableContent__ParameterInfo* */ parameters, QObject* parent); -void QScxmlDynamicScxmlServiceFactory_virtbase(QScxmlDynamicScxmlServiceFactory* src, QScxmlInvokableServiceFactory** outptr_QScxmlInvokableServiceFactory); -QMetaObject* QScxmlDynamicScxmlServiceFactory_metaObject(const QScxmlDynamicScxmlServiceFactory* self); -void* QScxmlDynamicScxmlServiceFactory_metacast(QScxmlDynamicScxmlServiceFactory* self, const char* param1); -struct miqt_string QScxmlDynamicScxmlServiceFactory_tr(const char* s); -QScxmlInvokableService* QScxmlDynamicScxmlServiceFactory_invoke(QScxmlDynamicScxmlServiceFactory* self, QScxmlStateMachine* parentStateMachine); -struct miqt_string QScxmlDynamicScxmlServiceFactory_tr2(const char* s, const char* c); -struct miqt_string QScxmlDynamicScxmlServiceFactory_tr3(const char* s, const char* c, int n); - -bool QScxmlDynamicScxmlServiceFactory_override_virtual_invoke(void* self, intptr_t slot); -QScxmlInvokableService* QScxmlDynamicScxmlServiceFactory_virtualbase_invoke(void* self, QScxmlStateMachine* parentStateMachine); -bool QScxmlDynamicScxmlServiceFactory_override_virtual_event(void* self, intptr_t slot); -bool QScxmlDynamicScxmlServiceFactory_virtualbase_event(void* self, QEvent* event); -bool QScxmlDynamicScxmlServiceFactory_override_virtual_eventFilter(void* self, intptr_t slot); -bool QScxmlDynamicScxmlServiceFactory_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); -bool QScxmlDynamicScxmlServiceFactory_override_virtual_timerEvent(void* self, intptr_t slot); -void QScxmlDynamicScxmlServiceFactory_virtualbase_timerEvent(void* self, QTimerEvent* event); -bool QScxmlDynamicScxmlServiceFactory_override_virtual_childEvent(void* self, intptr_t slot); -void QScxmlDynamicScxmlServiceFactory_virtualbase_childEvent(void* self, QChildEvent* event); -bool QScxmlDynamicScxmlServiceFactory_override_virtual_customEvent(void* self, intptr_t slot); -void QScxmlDynamicScxmlServiceFactory_virtualbase_customEvent(void* self, QEvent* event); -bool QScxmlDynamicScxmlServiceFactory_override_virtual_connectNotify(void* self, intptr_t slot); -void QScxmlDynamicScxmlServiceFactory_virtualbase_connectNotify(void* self, QMetaMethod* signal); -bool QScxmlDynamicScxmlServiceFactory_override_virtual_disconnectNotify(void* self, intptr_t slot); -void QScxmlDynamicScxmlServiceFactory_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - -QObject* QScxmlDynamicScxmlServiceFactory_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); -int QScxmlDynamicScxmlServiceFactory_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); -int QScxmlDynamicScxmlServiceFactory_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); -bool QScxmlDynamicScxmlServiceFactory_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); - -void QScxmlDynamicScxmlServiceFactory_delete(QScxmlDynamicScxmlServiceFactory* self); - -#ifdef __cplusplus -} /* extern C */ -#endif - -#endif diff --git a/qt6/scxml/gen_qscxmlnulldatamodel.cpp b/qt6/scxml/gen_qscxmlnulldatamodel.cpp deleted file mode 100644 index 68d94b8df..000000000 --- a/qt6/scxml/gen_qscxmlnulldatamodel.cpp +++ /dev/null @@ -1,901 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlDataModel__ForeachLoopBody -#include -#include -#include -#include -#include -#include -#include -#include -#include "gen_qscxmlnulldatamodel.h" - -#ifdef __cplusplus -extern "C" { -#endif - -bool miqt_exec_callback_QScxmlNullDataModel_setup(QScxmlNullDataModel*, intptr_t, struct miqt_map /* of struct miqt_string to QVariant* */ ); -struct miqt_string miqt_exec_callback_QScxmlNullDataModel_evaluateToString(QScxmlNullDataModel*, intptr_t, int, bool*); -bool miqt_exec_callback_QScxmlNullDataModel_evaluateToBool(QScxmlNullDataModel*, intptr_t, int, bool*); -QVariant* miqt_exec_callback_QScxmlNullDataModel_evaluateToVariant(QScxmlNullDataModel*, intptr_t, int, bool*); -void miqt_exec_callback_QScxmlNullDataModel_evaluateToVoid(QScxmlNullDataModel*, intptr_t, int, bool*); -void miqt_exec_callback_QScxmlNullDataModel_evaluateAssignment(QScxmlNullDataModel*, intptr_t, int, bool*); -void miqt_exec_callback_QScxmlNullDataModel_evaluateInitialization(QScxmlNullDataModel*, intptr_t, int, bool*); -void miqt_exec_callback_QScxmlNullDataModel_evaluateForeach(QScxmlNullDataModel*, intptr_t, int, bool*, QScxmlDataModel__ForeachLoopBody*); -void miqt_exec_callback_QScxmlNullDataModel_setScxmlEvent(QScxmlNullDataModel*, intptr_t, QScxmlEvent*); -QVariant* miqt_exec_callback_QScxmlNullDataModel_scxmlProperty(const QScxmlNullDataModel*, intptr_t, struct miqt_string); -bool miqt_exec_callback_QScxmlNullDataModel_hasScxmlProperty(const QScxmlNullDataModel*, intptr_t, struct miqt_string); -bool miqt_exec_callback_QScxmlNullDataModel_setScxmlProperty(QScxmlNullDataModel*, intptr_t, struct miqt_string, QVariant*, struct miqt_string); -bool miqt_exec_callback_QScxmlNullDataModel_event(QScxmlNullDataModel*, intptr_t, QEvent*); -bool miqt_exec_callback_QScxmlNullDataModel_eventFilter(QScxmlNullDataModel*, intptr_t, QObject*, QEvent*); -void miqt_exec_callback_QScxmlNullDataModel_timerEvent(QScxmlNullDataModel*, intptr_t, QTimerEvent*); -void miqt_exec_callback_QScxmlNullDataModel_childEvent(QScxmlNullDataModel*, intptr_t, QChildEvent*); -void miqt_exec_callback_QScxmlNullDataModel_customEvent(QScxmlNullDataModel*, intptr_t, QEvent*); -void miqt_exec_callback_QScxmlNullDataModel_connectNotify(QScxmlNullDataModel*, intptr_t, QMetaMethod*); -void miqt_exec_callback_QScxmlNullDataModel_disconnectNotify(QScxmlNullDataModel*, intptr_t, QMetaMethod*); -#ifdef __cplusplus -} /* extern C */ -#endif - -class MiqtVirtualQScxmlNullDataModel final : public QScxmlNullDataModel { -public: - - MiqtVirtualQScxmlNullDataModel(): QScxmlNullDataModel() {} - MiqtVirtualQScxmlNullDataModel(QObject* parent): QScxmlNullDataModel(parent) {} - - virtual ~MiqtVirtualQScxmlNullDataModel() override = default; - - // cgo.Handle value for overwritten implementation - intptr_t handle__setup = 0; - - // Subclass to allow providing a Go implementation - virtual bool setup(const QVariantMap& initialDataValues) override { - if (handle__setup == 0) { - return QScxmlNullDataModel::setup(initialDataValues); - } - - const QVariantMap& initialDataValues_ret = initialDataValues; - // Convert QMap<> from C++ memory to manually-managed C memory - struct miqt_string* initialDataValues_karr = static_cast(malloc(sizeof(struct miqt_string) * initialDataValues_ret.size())); - QVariant** initialDataValues_varr = static_cast(malloc(sizeof(QVariant*) * initialDataValues_ret.size())); - int initialDataValues_ctr = 0; - for (auto initialDataValues_itr = initialDataValues_ret.keyValueBegin(); initialDataValues_itr != initialDataValues_ret.keyValueEnd(); ++initialDataValues_itr) { - QString initialDataValues_mapkey_ret = initialDataValues_itr->first; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray initialDataValues_mapkey_b = initialDataValues_mapkey_ret.toUtf8(); - struct miqt_string initialDataValues_mapkey_ms; - initialDataValues_mapkey_ms.len = initialDataValues_mapkey_b.length(); - initialDataValues_mapkey_ms.data = static_cast(malloc(initialDataValues_mapkey_ms.len)); - memcpy(initialDataValues_mapkey_ms.data, initialDataValues_mapkey_b.data(), initialDataValues_mapkey_ms.len); - initialDataValues_karr[initialDataValues_ctr] = initialDataValues_mapkey_ms; - initialDataValues_varr[initialDataValues_ctr] = new QVariant(initialDataValues_itr->second); - initialDataValues_ctr++; - } - struct miqt_map initialDataValues_out; - initialDataValues_out.len = initialDataValues_ret.size(); - initialDataValues_out.keys = static_cast(initialDataValues_karr); - initialDataValues_out.values = static_cast(initialDataValues_varr); - struct miqt_map /* of struct miqt_string to QVariant* */ sigval1 = initialDataValues_out; - bool callback_return_value = miqt_exec_callback_QScxmlNullDataModel_setup(this, handle__setup, sigval1); - return callback_return_value; - } - - friend bool QScxmlNullDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateToString = 0; - - // Subclass to allow providing a Go implementation - virtual QString evaluateToString(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateToString == 0) { - return QScxmlNullDataModel::evaluateToString(id, ok); - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - struct miqt_string callback_return_value = miqt_exec_callback_QScxmlNullDataModel_evaluateToString(this, handle__evaluateToString, sigval1, sigval2); - QString callback_return_value_QString = QString::fromUtf8(callback_return_value.data, callback_return_value.len); - return callback_return_value_QString; - } - - friend struct miqt_string QScxmlNullDataModel_virtualbase_evaluateToString(void* self, int id, bool* ok); - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateToBool = 0; - - // Subclass to allow providing a Go implementation - virtual bool evaluateToBool(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateToBool == 0) { - return QScxmlNullDataModel::evaluateToBool(id, ok); - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - bool callback_return_value = miqt_exec_callback_QScxmlNullDataModel_evaluateToBool(this, handle__evaluateToBool, sigval1, sigval2); - return callback_return_value; - } - - friend bool QScxmlNullDataModel_virtualbase_evaluateToBool(void* self, int id, bool* ok); - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateToVariant = 0; - - // Subclass to allow providing a Go implementation - virtual QVariant evaluateToVariant(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateToVariant == 0) { - return QScxmlNullDataModel::evaluateToVariant(id, ok); - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - QVariant* callback_return_value = miqt_exec_callback_QScxmlNullDataModel_evaluateToVariant(this, handle__evaluateToVariant, sigval1, sigval2); - return *callback_return_value; - } - - friend QVariant* QScxmlNullDataModel_virtualbase_evaluateToVariant(void* self, int id, bool* ok); - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateToVoid = 0; - - // Subclass to allow providing a Go implementation - virtual void evaluateToVoid(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateToVoid == 0) { - QScxmlNullDataModel::evaluateToVoid(id, ok); - return; - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - miqt_exec_callback_QScxmlNullDataModel_evaluateToVoid(this, handle__evaluateToVoid, sigval1, sigval2); - - } - - friend void QScxmlNullDataModel_virtualbase_evaluateToVoid(void* self, int id, bool* ok); - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateAssignment = 0; - - // Subclass to allow providing a Go implementation - virtual void evaluateAssignment(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateAssignment == 0) { - QScxmlNullDataModel::evaluateAssignment(id, ok); - return; - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - miqt_exec_callback_QScxmlNullDataModel_evaluateAssignment(this, handle__evaluateAssignment, sigval1, sigval2); - - } - - friend void QScxmlNullDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok); - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateInitialization = 0; - - // Subclass to allow providing a Go implementation - virtual void evaluateInitialization(QScxmlExecutableContent::EvaluatorId id, bool* ok) override { - if (handle__evaluateInitialization == 0) { - QScxmlNullDataModel::evaluateInitialization(id, ok); - return; - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - miqt_exec_callback_QScxmlNullDataModel_evaluateInitialization(this, handle__evaluateInitialization, sigval1, sigval2); - - } - - friend void QScxmlNullDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok); - - // cgo.Handle value for overwritten implementation - intptr_t handle__evaluateForeach = 0; - - // Subclass to allow providing a Go implementation - virtual void evaluateForeach(QScxmlExecutableContent::EvaluatorId id, bool* ok, QScxmlDataModel::ForeachLoopBody* body) override { - if (handle__evaluateForeach == 0) { - QScxmlNullDataModel::evaluateForeach(id, ok, body); - return; - } - - QScxmlExecutableContent::EvaluatorId id_ret = id; - int sigval1 = static_cast(id_ret); - bool* sigval2 = ok; - QScxmlDataModel__ForeachLoopBody* sigval3 = body; - miqt_exec_callback_QScxmlNullDataModel_evaluateForeach(this, handle__evaluateForeach, sigval1, sigval2, sigval3); - - } - - friend void QScxmlNullDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); - - // cgo.Handle value for overwritten implementation - intptr_t handle__setScxmlEvent = 0; - - // Subclass to allow providing a Go implementation - virtual void setScxmlEvent(const QScxmlEvent& event) override { - if (handle__setScxmlEvent == 0) { - QScxmlNullDataModel::setScxmlEvent(event); - return; - } - - const QScxmlEvent& event_ret = event; - // Cast returned reference into pointer - QScxmlEvent* sigval1 = const_cast(&event_ret); - miqt_exec_callback_QScxmlNullDataModel_setScxmlEvent(this, handle__setScxmlEvent, sigval1); - - } - - friend void QScxmlNullDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* event); - - // cgo.Handle value for overwritten implementation - intptr_t handle__scxmlProperty = 0; - - // Subclass to allow providing a Go implementation - virtual QVariant scxmlProperty(const QString& name) const override { - if (handle__scxmlProperty == 0) { - return QScxmlNullDataModel::scxmlProperty(name); - } - - const QString name_ret = name; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray name_b = name_ret.toUtf8(); - struct miqt_string name_ms; - name_ms.len = name_b.length(); - name_ms.data = static_cast(malloc(name_ms.len)); - memcpy(name_ms.data, name_b.data(), name_ms.len); - struct miqt_string sigval1 = name_ms; - QVariant* callback_return_value = miqt_exec_callback_QScxmlNullDataModel_scxmlProperty(this, handle__scxmlProperty, sigval1); - return *callback_return_value; - } - - friend QVariant* QScxmlNullDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name); - - // cgo.Handle value for overwritten implementation - intptr_t handle__hasScxmlProperty = 0; - - // Subclass to allow providing a Go implementation - virtual bool hasScxmlProperty(const QString& name) const override { - if (handle__hasScxmlProperty == 0) { - return QScxmlNullDataModel::hasScxmlProperty(name); - } - - const QString name_ret = name; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray name_b = name_ret.toUtf8(); - struct miqt_string name_ms; - name_ms.len = name_b.length(); - name_ms.data = static_cast(malloc(name_ms.len)); - memcpy(name_ms.data, name_b.data(), name_ms.len); - struct miqt_string sigval1 = name_ms; - bool callback_return_value = miqt_exec_callback_QScxmlNullDataModel_hasScxmlProperty(this, handle__hasScxmlProperty, sigval1); - return callback_return_value; - } - - friend bool QScxmlNullDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name); - - // cgo.Handle value for overwritten implementation - intptr_t handle__setScxmlProperty = 0; - - // Subclass to allow providing a Go implementation - virtual bool setScxmlProperty(const QString& name, const QVariant& value, const QString& context) override { - if (handle__setScxmlProperty == 0) { - return QScxmlNullDataModel::setScxmlProperty(name, value, context); - } - - const QString name_ret = name; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray name_b = name_ret.toUtf8(); - struct miqt_string name_ms; - name_ms.len = name_b.length(); - name_ms.data = static_cast(malloc(name_ms.len)); - memcpy(name_ms.data, name_b.data(), name_ms.len); - struct miqt_string sigval1 = name_ms; - const QVariant& value_ret = value; - // Cast returned reference into pointer - QVariant* sigval2 = const_cast(&value_ret); - const QString context_ret = context; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray context_b = context_ret.toUtf8(); - struct miqt_string context_ms; - context_ms.len = context_b.length(); - context_ms.data = static_cast(malloc(context_ms.len)); - memcpy(context_ms.data, context_b.data(), context_ms.len); - struct miqt_string sigval3 = context_ms; - bool callback_return_value = miqt_exec_callback_QScxmlNullDataModel_setScxmlProperty(this, handle__setScxmlProperty, sigval1, sigval2, sigval3); - return callback_return_value; - } - - friend bool QScxmlNullDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context); - - // 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 QScxmlNullDataModel::event(event); - } - - QEvent* sigval1 = event; - bool callback_return_value = miqt_exec_callback_QScxmlNullDataModel_event(this, handle__event, sigval1); - return callback_return_value; - } - - friend bool QScxmlNullDataModel_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 QScxmlNullDataModel::eventFilter(watched, event); - } - - QObject* sigval1 = watched; - QEvent* sigval2 = event; - bool callback_return_value = miqt_exec_callback_QScxmlNullDataModel_eventFilter(this, handle__eventFilter, sigval1, sigval2); - return callback_return_value; - } - - friend bool QScxmlNullDataModel_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) { - QScxmlNullDataModel::timerEvent(event); - return; - } - - QTimerEvent* sigval1 = event; - miqt_exec_callback_QScxmlNullDataModel_timerEvent(this, handle__timerEvent, sigval1); - - } - - friend void QScxmlNullDataModel_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) { - QScxmlNullDataModel::childEvent(event); - return; - } - - QChildEvent* sigval1 = event; - miqt_exec_callback_QScxmlNullDataModel_childEvent(this, handle__childEvent, sigval1); - - } - - friend void QScxmlNullDataModel_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) { - QScxmlNullDataModel::customEvent(event); - return; - } - - QEvent* sigval1 = event; - miqt_exec_callback_QScxmlNullDataModel_customEvent(this, handle__customEvent, sigval1); - - } - - friend void QScxmlNullDataModel_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) { - QScxmlNullDataModel::connectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlNullDataModel_connectNotify(this, handle__connectNotify, sigval1); - - } - - friend void QScxmlNullDataModel_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) { - QScxmlNullDataModel::disconnectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QScxmlNullDataModel_disconnectNotify(this, handle__disconnectNotify, sigval1); - - } - - friend void QScxmlNullDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - - // Wrappers to allow calling protected methods: - friend QObject* QScxmlNullDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlNullDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); - friend int QScxmlNullDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); - friend bool QScxmlNullDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); -}; - -QScxmlNullDataModel* QScxmlNullDataModel_new() { - return new (std::nothrow) MiqtVirtualQScxmlNullDataModel(); -} - -QScxmlNullDataModel* QScxmlNullDataModel_new2(QObject* parent) { - return new (std::nothrow) MiqtVirtualQScxmlNullDataModel(parent); -} - -void QScxmlNullDataModel_virtbase(QScxmlNullDataModel* src, QScxmlDataModel** outptr_QScxmlDataModel) { - *outptr_QScxmlDataModel = static_cast(src); -} - -QMetaObject* QScxmlNullDataModel_metaObject(const QScxmlNullDataModel* self) { - return (QMetaObject*) self->metaObject(); -} - -void* QScxmlNullDataModel_metacast(QScxmlNullDataModel* self, const char* param1) { - return self->qt_metacast(param1); -} - -struct miqt_string QScxmlNullDataModel_tr(const char* s) { - QString _ret = QScxmlNullDataModel::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; -} - -bool QScxmlNullDataModel_setup(QScxmlNullDataModel* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues) { - QVariantMap initialDataValues_QMap; - struct miqt_string* initialDataValues_karr = static_cast(initialDataValues.keys); - QVariant** initialDataValues_varr = static_cast(initialDataValues.values); - for(size_t i = 0; i < initialDataValues.len; ++i) { - QString initialDataValues_karr_i_QString = QString::fromUtf8(initialDataValues_karr[i].data, initialDataValues_karr[i].len); - initialDataValues_QMap[initialDataValues_karr_i_QString] = *(initialDataValues_varr[i]); - } - return self->setup(initialDataValues_QMap); -} - -struct miqt_string QScxmlNullDataModel_evaluateToString(QScxmlNullDataModel* self, int id, bool* ok) { - QString _ret = self->evaluateToString(static_cast(id), ok); - // 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 QScxmlNullDataModel_evaluateToBool(QScxmlNullDataModel* self, int id, bool* ok) { - return self->evaluateToBool(static_cast(id), ok); -} - -QVariant* QScxmlNullDataModel_evaluateToVariant(QScxmlNullDataModel* self, int id, bool* ok) { - return new QVariant(self->evaluateToVariant(static_cast(id), ok)); -} - -void QScxmlNullDataModel_evaluateToVoid(QScxmlNullDataModel* self, int id, bool* ok) { - self->evaluateToVoid(static_cast(id), ok); -} - -void QScxmlNullDataModel_evaluateAssignment(QScxmlNullDataModel* self, int id, bool* ok) { - self->evaluateAssignment(static_cast(id), ok); -} - -void QScxmlNullDataModel_evaluateInitialization(QScxmlNullDataModel* self, int id, bool* ok) { - self->evaluateInitialization(static_cast(id), ok); -} - -void QScxmlNullDataModel_evaluateForeach(QScxmlNullDataModel* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body) { - self->evaluateForeach(static_cast(id), ok, body); -} - -void QScxmlNullDataModel_setScxmlEvent(QScxmlNullDataModel* self, QScxmlEvent* event) { - self->setScxmlEvent(*event); -} - -QVariant* QScxmlNullDataModel_scxmlProperty(const QScxmlNullDataModel* self, struct miqt_string name) { - QString name_QString = QString::fromUtf8(name.data, name.len); - return new QVariant(self->scxmlProperty(name_QString)); -} - -bool QScxmlNullDataModel_hasScxmlProperty(const QScxmlNullDataModel* self, struct miqt_string name) { - QString name_QString = QString::fromUtf8(name.data, name.len); - return self->hasScxmlProperty(name_QString); -} - -bool QScxmlNullDataModel_setScxmlProperty(QScxmlNullDataModel* self, struct miqt_string name, QVariant* value, struct miqt_string context) { - QString name_QString = QString::fromUtf8(name.data, name.len); - QString context_QString = QString::fromUtf8(context.data, context.len); - return self->setScxmlProperty(name_QString, *value, context_QString); -} - -struct miqt_string QScxmlNullDataModel_tr2(const char* s, const char* c) { - QString _ret = QScxmlNullDataModel::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 QScxmlNullDataModel_tr3(const char* s, const char* c, int n) { - QString _ret = QScxmlNullDataModel::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 QScxmlNullDataModel_override_virtual_setup(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__setup = slot; - return true; -} - -bool QScxmlNullDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues) { - QVariantMap initialDataValues_QMap; - struct miqt_string* initialDataValues_karr = static_cast(initialDataValues.keys); - QVariant** initialDataValues_varr = static_cast(initialDataValues.values); - for(size_t i = 0; i < initialDataValues.len; ++i) { - QString initialDataValues_karr_i_QString = QString::fromUtf8(initialDataValues_karr[i].data, initialDataValues_karr[i].len); - initialDataValues_QMap[initialDataValues_karr_i_QString] = *(initialDataValues_varr[i]); - } - return static_cast(self)->QScxmlNullDataModel::setup(initialDataValues_QMap); -} - -bool QScxmlNullDataModel_override_virtual_evaluateToString(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateToString = slot; - return true; -} - -struct miqt_string QScxmlNullDataModel_virtualbase_evaluateToString(void* self, int id, bool* ok) { - QString _ret = static_cast(self)->QScxmlNullDataModel::evaluateToString(static_cast(id), ok); - // 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 QScxmlNullDataModel_override_virtual_evaluateToBool(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateToBool = slot; - return true; -} - -bool QScxmlNullDataModel_virtualbase_evaluateToBool(void* self, int id, bool* ok) { - return static_cast(self)->QScxmlNullDataModel::evaluateToBool(static_cast(id), ok); -} - -bool QScxmlNullDataModel_override_virtual_evaluateToVariant(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateToVariant = slot; - return true; -} - -QVariant* QScxmlNullDataModel_virtualbase_evaluateToVariant(void* self, int id, bool* ok) { - return new QVariant(static_cast(self)->QScxmlNullDataModel::evaluateToVariant(static_cast(id), ok)); -} - -bool QScxmlNullDataModel_override_virtual_evaluateToVoid(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateToVoid = slot; - return true; -} - -void QScxmlNullDataModel_virtualbase_evaluateToVoid(void* self, int id, bool* ok) { - static_cast(self)->QScxmlNullDataModel::evaluateToVoid(static_cast(id), ok); -} - -bool QScxmlNullDataModel_override_virtual_evaluateAssignment(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateAssignment = slot; - return true; -} - -void QScxmlNullDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok) { - static_cast(self)->QScxmlNullDataModel::evaluateAssignment(static_cast(id), ok); -} - -bool QScxmlNullDataModel_override_virtual_evaluateInitialization(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateInitialization = slot; - return true; -} - -void QScxmlNullDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok) { - static_cast(self)->QScxmlNullDataModel::evaluateInitialization(static_cast(id), ok); -} - -bool QScxmlNullDataModel_override_virtual_evaluateForeach(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__evaluateForeach = slot; - return true; -} - -void QScxmlNullDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body) { - static_cast(self)->QScxmlNullDataModel::evaluateForeach(static_cast(id), ok, body); -} - -bool QScxmlNullDataModel_override_virtual_setScxmlEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__setScxmlEvent = slot; - return true; -} - -void QScxmlNullDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* event) { - static_cast(self)->QScxmlNullDataModel::setScxmlEvent(*event); -} - -bool QScxmlNullDataModel_override_virtual_scxmlProperty(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__scxmlProperty = slot; - return true; -} - -QVariant* QScxmlNullDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name) { - QString name_QString = QString::fromUtf8(name.data, name.len); - return new QVariant(static_cast(self)->QScxmlNullDataModel::scxmlProperty(name_QString)); -} - -bool QScxmlNullDataModel_override_virtual_hasScxmlProperty(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__hasScxmlProperty = slot; - return true; -} - -bool QScxmlNullDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name) { - QString name_QString = QString::fromUtf8(name.data, name.len); - return static_cast(self)->QScxmlNullDataModel::hasScxmlProperty(name_QString); -} - -bool QScxmlNullDataModel_override_virtual_setScxmlProperty(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__setScxmlProperty = slot; - return true; -} - -bool QScxmlNullDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context) { - QString name_QString = QString::fromUtf8(name.data, name.len); - QString context_QString = QString::fromUtf8(context.data, context.len); - return static_cast(self)->QScxmlNullDataModel::setScxmlProperty(name_QString, *value, context_QString); -} - -bool QScxmlNullDataModel_override_virtual_event(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__event = slot; - return true; -} - -bool QScxmlNullDataModel_virtualbase_event(void* self, QEvent* event) { - return static_cast(self)->QScxmlNullDataModel::event(event); -} - -bool QScxmlNullDataModel_override_virtual_eventFilter(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__eventFilter = slot; - return true; -} - -bool QScxmlNullDataModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { - return static_cast(self)->QScxmlNullDataModel::eventFilter(watched, event); -} - -bool QScxmlNullDataModel_override_virtual_timerEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__timerEvent = slot; - return true; -} - -void QScxmlNullDataModel_virtualbase_timerEvent(void* self, QTimerEvent* event) { - static_cast(self)->QScxmlNullDataModel::timerEvent(event); -} - -bool QScxmlNullDataModel_override_virtual_childEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__childEvent = slot; - return true; -} - -void QScxmlNullDataModel_virtualbase_childEvent(void* self, QChildEvent* event) { - static_cast(self)->QScxmlNullDataModel::childEvent(event); -} - -bool QScxmlNullDataModel_override_virtual_customEvent(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__customEvent = slot; - return true; -} - -void QScxmlNullDataModel_virtualbase_customEvent(void* self, QEvent* event) { - static_cast(self)->QScxmlNullDataModel::customEvent(event); -} - -bool QScxmlNullDataModel_override_virtual_connectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__connectNotify = slot; - return true; -} - -void QScxmlNullDataModel_virtualbase_connectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlNullDataModel::connectNotify(*signal); -} - -bool QScxmlNullDataModel_override_virtual_disconnectNotify(void* self, intptr_t slot) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__disconnectNotify = slot; - return true; -} - -void QScxmlNullDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QScxmlNullDataModel::disconnectNotify(*signal); -} - -QObject* QScxmlNullDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return nullptr; - } - - *_dynamic_cast_ok = true; - return self_cast->sender(); -} - -int QScxmlNullDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->senderSignalIndex(); -} - -int QScxmlNullDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->receivers(signal); -} - -bool QScxmlNullDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { - MiqtVirtualQScxmlNullDataModel* self_cast = dynamic_cast( (QScxmlNullDataModel*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return false; - } - - *_dynamic_cast_ok = true; - return self_cast->isSignalConnected(*signal); -} - -void QScxmlNullDataModel_delete(QScxmlNullDataModel* self) { - delete self; -} - diff --git a/qt6/scxml/gen_qscxmlnulldatamodel.go b/qt6/scxml/gen_qscxmlnulldatamodel.go deleted file mode 100644 index b34b1a9b6..000000000 --- a/qt6/scxml/gen_qscxmlnulldatamodel.go +++ /dev/null @@ -1,872 +0,0 @@ -package scxml - -/* - -#include "gen_qscxmlnulldatamodel.h" -#include - -*/ -import "C" - -import ( - "github.com/mappu/miqt/qt6" - "runtime" - "runtime/cgo" - "unsafe" -) - -type QScxmlNullDataModel struct { - h *C.QScxmlNullDataModel - *QScxmlDataModel -} - -func (this *QScxmlNullDataModel) cPointer() *C.QScxmlNullDataModel { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlNullDataModel) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlNullDataModel constructs the type using only CGO pointers. -func newQScxmlNullDataModel(h *C.QScxmlNullDataModel) *QScxmlNullDataModel { - if h == nil { - return nil - } - var outptr_QScxmlDataModel *C.QScxmlDataModel = nil - C.QScxmlNullDataModel_virtbase(h, &outptr_QScxmlDataModel) - - return &QScxmlNullDataModel{h: h, - QScxmlDataModel: newQScxmlDataModel(outptr_QScxmlDataModel)} -} - -// UnsafeNewQScxmlNullDataModel constructs the type using only unsafe pointers. -func UnsafeNewQScxmlNullDataModel(h unsafe.Pointer) *QScxmlNullDataModel { - return newQScxmlNullDataModel((*C.QScxmlNullDataModel)(h)) -} - -// NewQScxmlNullDataModel constructs a new QScxmlNullDataModel object. -func NewQScxmlNullDataModel() *QScxmlNullDataModel { - - return newQScxmlNullDataModel(C.QScxmlNullDataModel_new()) -} - -// NewQScxmlNullDataModel2 constructs a new QScxmlNullDataModel object. -func NewQScxmlNullDataModel2(parent *qt6.QObject) *QScxmlNullDataModel { - - return newQScxmlNullDataModel(C.QScxmlNullDataModel_new2((*C.QObject)(parent.UnsafePointer()))) -} - -func (this *QScxmlNullDataModel) MetaObject() *qt6.QMetaObject { - return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlNullDataModel_metaObject(this.h))) -} - -func (this *QScxmlNullDataModel) Metacast(param1 string) unsafe.Pointer { - param1_Cstring := C.CString(param1) - defer C.free(unsafe.Pointer(param1_Cstring)) - return (unsafe.Pointer)(C.QScxmlNullDataModel_metacast(this.h, param1_Cstring)) -} - -func QScxmlNullDataModel_Tr(s string) string { - s_Cstring := C.CString(s) - defer C.free(unsafe.Pointer(s_Cstring)) - var _ms C.struct_miqt_string = C.QScxmlNullDataModel_tr(s_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlNullDataModel) Setup(initialDataValues map[string]qt6.QVariant) bool { - initialDataValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialDataValues)))) - defer C.free(unsafe.Pointer(initialDataValues_Keys_CArray)) - initialDataValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialDataValues)))) - defer C.free(unsafe.Pointer(initialDataValues_Values_CArray)) - initialDataValues_ctr := 0 - for initialDataValues_k, initialDataValues_v := range initialDataValues { - initialDataValues_k_ms := C.struct_miqt_string{} - initialDataValues_k_ms.data = C.CString(initialDataValues_k) - initialDataValues_k_ms.len = C.size_t(len(initialDataValues_k)) - defer C.free(unsafe.Pointer(initialDataValues_k_ms.data)) - initialDataValues_Keys_CArray[initialDataValues_ctr] = initialDataValues_k_ms - initialDataValues_Values_CArray[initialDataValues_ctr] = (*C.QVariant)(initialDataValues_v.UnsafePointer()) - initialDataValues_ctr++ - } - initialDataValues_mm := C.struct_miqt_map{ - len: C.size_t(len(initialDataValues)), - keys: unsafe.Pointer(initialDataValues_Keys_CArray), - values: unsafe.Pointer(initialDataValues_Values_CArray), - } - return (bool)(C.QScxmlNullDataModel_setup(this.h, initialDataValues_mm)) -} - -func (this *QScxmlNullDataModel) EvaluateToString(id int, ok *bool) string { - var _ms C.struct_miqt_string = C.QScxmlNullDataModel_evaluateToString(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlNullDataModel) EvaluateToBool(id int, ok *bool) bool { - return (bool)(C.QScxmlNullDataModel_evaluateToBool(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok)))) -} - -func (this *QScxmlNullDataModel) EvaluateToVariant(id int, ok *bool) *qt6.QVariant { - _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlNullDataModel_evaluateToVariant(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -func (this *QScxmlNullDataModel) EvaluateToVoid(id int, ok *bool) { - C.QScxmlNullDataModel_evaluateToVoid(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) -} - -func (this *QScxmlNullDataModel) EvaluateAssignment(id int, ok *bool) { - C.QScxmlNullDataModel_evaluateAssignment(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) -} - -func (this *QScxmlNullDataModel) EvaluateInitialization(id int, ok *bool) { - C.QScxmlNullDataModel_evaluateInitialization(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) -} - -func (this *QScxmlNullDataModel) EvaluateForeach(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody) { - C.QScxmlNullDataModel_evaluateForeach(this.h, (C.int)(id), (*C.bool)(unsafe.Pointer(ok)), body.cPointer()) -} - -func (this *QScxmlNullDataModel) SetScxmlEvent(event *QScxmlEvent) { - C.QScxmlNullDataModel_setScxmlEvent(this.h, event.cPointer()) -} - -func (this *QScxmlNullDataModel) ScxmlProperty(name string) *qt6.QVariant { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlNullDataModel_scxmlProperty(this.h, name_ms))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -func (this *QScxmlNullDataModel) HasScxmlProperty(name string) bool { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - return (bool)(C.QScxmlNullDataModel_hasScxmlProperty(this.h, name_ms)) -} - -func (this *QScxmlNullDataModel) SetScxmlProperty(name string, value *qt6.QVariant, context string) bool { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - context_ms := C.struct_miqt_string{} - context_ms.data = C.CString(context) - context_ms.len = C.size_t(len(context)) - defer C.free(unsafe.Pointer(context_ms.data)) - return (bool)(C.QScxmlNullDataModel_setScxmlProperty(this.h, name_ms, (*C.QVariant)(value.UnsafePointer()), context_ms)) -} - -func QScxmlNullDataModel_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.QScxmlNullDataModel_tr2(s_Cstring, c_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func QScxmlNullDataModel_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.QScxmlNullDataModel_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 -} - -// Sender can only be called from a QScxmlNullDataModel that was directly constructed. -func (this *QScxmlNullDataModel) Sender() *qt6.QObject { - - var _dynamic_cast_ok C.bool = false - _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QScxmlNullDataModel_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 QScxmlNullDataModel that was directly constructed. -func (this *QScxmlNullDataModel) SenderSignalIndex() int { - - var _dynamic_cast_ok C.bool = false - _method_ret := (int)(C.QScxmlNullDataModel_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 QScxmlNullDataModel that was directly constructed. -func (this *QScxmlNullDataModel) 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.QScxmlNullDataModel_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 QScxmlNullDataModel that was directly constructed. -func (this *QScxmlNullDataModel) IsSignalConnected(signal *qt6.QMetaMethod) bool { - - var _dynamic_cast_ok C.bool = false - _method_ret := (bool)(C.QScxmlNullDataModel_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 *QScxmlNullDataModel) callVirtualBase_Setup(initialDataValues map[string]qt6.QVariant) bool { - initialDataValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialDataValues)))) - defer C.free(unsafe.Pointer(initialDataValues_Keys_CArray)) - initialDataValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialDataValues)))) - defer C.free(unsafe.Pointer(initialDataValues_Values_CArray)) - initialDataValues_ctr := 0 - for initialDataValues_k, initialDataValues_v := range initialDataValues { - initialDataValues_k_ms := C.struct_miqt_string{} - initialDataValues_k_ms.data = C.CString(initialDataValues_k) - initialDataValues_k_ms.len = C.size_t(len(initialDataValues_k)) - defer C.free(unsafe.Pointer(initialDataValues_k_ms.data)) - initialDataValues_Keys_CArray[initialDataValues_ctr] = initialDataValues_k_ms - initialDataValues_Values_CArray[initialDataValues_ctr] = (*C.QVariant)(initialDataValues_v.UnsafePointer()) - initialDataValues_ctr++ - } - initialDataValues_mm := C.struct_miqt_map{ - len: C.size_t(len(initialDataValues)), - keys: unsafe.Pointer(initialDataValues_Keys_CArray), - values: unsafe.Pointer(initialDataValues_Values_CArray), - } - - return (bool)(C.QScxmlNullDataModel_virtualbase_setup(unsafe.Pointer(this.h), initialDataValues_mm)) - -} -func (this *QScxmlNullDataModel) OnSetup(slot func(super func(initialDataValues map[string]qt6.QVariant) bool, initialDataValues map[string]qt6.QVariant) bool) { - ok := C.QScxmlNullDataModel_override_virtual_setup(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlNullDataModel_setup -func miqt_exec_callback_QScxmlNullDataModel_setup(self *C.QScxmlNullDataModel, cb C.intptr_t, initialDataValues C.struct_miqt_map) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(initialDataValues map[string]qt6.QVariant) bool, initialDataValues map[string]qt6.QVariant) bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var initialDataValues_mm C.struct_miqt_map = initialDataValues - initialDataValues_ret := make(map[string]qt6.QVariant, int(initialDataValues_mm.len)) - initialDataValues_Keys := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(initialDataValues_mm.keys)) - initialDataValues_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(initialDataValues_mm.values)) - for i := 0; i < int(initialDataValues_mm.len); i++ { - var initialDataValues_mapkey_ms C.struct_miqt_string = initialDataValues_Keys[i] - initialDataValues_mapkey_ret := C.GoStringN(initialDataValues_mapkey_ms.data, C.int(int64(initialDataValues_mapkey_ms.len))) - C.free(unsafe.Pointer(initialDataValues_mapkey_ms.data)) - initialDataValues_entry_Key := initialDataValues_mapkey_ret - initialDataValues_mapval_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(initialDataValues_Values[i])) - initialDataValues_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - initialDataValues_entry_Value := *initialDataValues_mapval_goptr - - initialDataValues_ret[initialDataValues_entry_Key] = initialDataValues_entry_Value - } - slotval1 := initialDataValues_ret - - virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_Setup, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_EvaluateToString(id int, ok *bool) string { - - var _ms C.struct_miqt_string = C.QScxmlNullDataModel_virtualbase_evaluateToString(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} -func (this *QScxmlNullDataModel) OnEvaluateToString(slot func(super func(id int, ok *bool) string, id int, ok *bool) string) { - ok := C.QScxmlNullDataModel_override_virtual_evaluateToString(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlNullDataModel_evaluateToString -func miqt_exec_callback_QScxmlNullDataModel_evaluateToString(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool) C.struct_miqt_string { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool) string, id int, ok *bool) string) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateToString, slotval1, slotval2) - virtualReturn_ms := C.struct_miqt_string{} - virtualReturn_ms.data = C.CString(virtualReturn) - virtualReturn_ms.len = C.size_t(len(virtualReturn)) - defer C.free(unsafe.Pointer(virtualReturn_ms.data)) - - return virtualReturn_ms - -} - -func (this *QScxmlNullDataModel) callVirtualBase_EvaluateToBool(id int, ok *bool) bool { - - return (bool)(C.QScxmlNullDataModel_virtualbase_evaluateToBool(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok)))) - -} -func (this *QScxmlNullDataModel) OnEvaluateToBool(slot func(super func(id int, ok *bool) bool, id int, ok *bool) bool) { - ok := C.QScxmlNullDataModel_override_virtual_evaluateToBool(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlNullDataModel_evaluateToBool -func miqt_exec_callback_QScxmlNullDataModel_evaluateToBool(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool) bool, id int, ok *bool) bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateToBool, slotval1, slotval2) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_EvaluateToVariant(id int, ok *bool) *qt6.QVariant { - - _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlNullDataModel_virtualbase_evaluateToVariant(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr - -} -func (this *QScxmlNullDataModel) OnEvaluateToVariant(slot func(super func(id int, ok *bool) *qt6.QVariant, id int, ok *bool) *qt6.QVariant) { - ok := C.QScxmlNullDataModel_override_virtual_evaluateToVariant(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlNullDataModel_evaluateToVariant -func miqt_exec_callback_QScxmlNullDataModel_evaluateToVariant(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool) *C.QVariant { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool) *qt6.QVariant, id int, ok *bool) *qt6.QVariant) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateToVariant, slotval1, slotval2) - - return (*C.QVariant)(virtualReturn.UnsafePointer()) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_EvaluateToVoid(id int, ok *bool) { - - C.QScxmlNullDataModel_virtualbase_evaluateToVoid(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) - -} -func (this *QScxmlNullDataModel) OnEvaluateToVoid(slot func(super func(id int, ok *bool), id int, ok *bool)) { - ok := C.QScxmlNullDataModel_override_virtual_evaluateToVoid(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlNullDataModel_evaluateToVoid -func miqt_exec_callback_QScxmlNullDataModel_evaluateToVoid(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool) { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool), id int, ok *bool)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateToVoid, slotval1, slotval2) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_EvaluateAssignment(id int, ok *bool) { - - C.QScxmlNullDataModel_virtualbase_evaluateAssignment(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) - -} -func (this *QScxmlNullDataModel) OnEvaluateAssignment(slot func(super func(id int, ok *bool), id int, ok *bool)) { - ok := C.QScxmlNullDataModel_override_virtual_evaluateAssignment(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlNullDataModel_evaluateAssignment -func miqt_exec_callback_QScxmlNullDataModel_evaluateAssignment(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool) { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool), id int, ok *bool)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateAssignment, slotval1, slotval2) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_EvaluateInitialization(id int, ok *bool) { - - C.QScxmlNullDataModel_virtualbase_evaluateInitialization(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok))) - -} -func (this *QScxmlNullDataModel) OnEvaluateInitialization(slot func(super func(id int, ok *bool), id int, ok *bool)) { - ok := C.QScxmlNullDataModel_override_virtual_evaluateInitialization(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlNullDataModel_evaluateInitialization -func miqt_exec_callback_QScxmlNullDataModel_evaluateInitialization(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool) { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool), id int, ok *bool)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateInitialization, slotval1, slotval2) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_EvaluateForeach(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody) { - - C.QScxmlNullDataModel_virtualbase_evaluateForeach(unsafe.Pointer(this.h), (C.int)(id), (*C.bool)(unsafe.Pointer(ok)), body.cPointer()) - -} -func (this *QScxmlNullDataModel) OnEvaluateForeach(slot func(super func(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody), id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody)) { - ok := C.QScxmlNullDataModel_override_virtual_evaluateForeach(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlNullDataModel_evaluateForeach -func miqt_exec_callback_QScxmlNullDataModel_evaluateForeach(self *C.QScxmlNullDataModel, cb C.intptr_t, id C.int, ok *C.bool, body *C.QScxmlDataModel__ForeachLoopBody) { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody), id int, ok *bool, body *QScxmlDataModel__ForeachLoopBody)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (int)(id) - - slotval2 := (*bool)(unsafe.Pointer(ok)) - - slotval3 := newQScxmlDataModel__ForeachLoopBody(body) - - gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_EvaluateForeach, slotval1, slotval2, slotval3) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_SetScxmlEvent(event *QScxmlEvent) { - - C.QScxmlNullDataModel_virtualbase_setScxmlEvent(unsafe.Pointer(this.h), event.cPointer()) - -} -func (this *QScxmlNullDataModel) OnSetScxmlEvent(slot func(super func(event *QScxmlEvent), event *QScxmlEvent)) { - ok := C.QScxmlNullDataModel_override_virtual_setScxmlEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlNullDataModel_setScxmlEvent -func miqt_exec_callback_QScxmlNullDataModel_setScxmlEvent(self *C.QScxmlNullDataModel, cb C.intptr_t, event *C.QScxmlEvent) { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QScxmlEvent), event *QScxmlEvent)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQScxmlEvent(event) - - gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_SetScxmlEvent, slotval1) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_ScxmlProperty(name string) *qt6.QVariant { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - - _goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QScxmlNullDataModel_virtualbase_scxmlProperty(unsafe.Pointer(this.h), name_ms))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr - -} -func (this *QScxmlNullDataModel) OnScxmlProperty(slot func(super func(name string) *qt6.QVariant, name string) *qt6.QVariant) { - ok := C.QScxmlNullDataModel_override_virtual_scxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlNullDataModel_scxmlProperty -func miqt_exec_callback_QScxmlNullDataModel_scxmlProperty(self *C.QScxmlNullDataModel, cb C.intptr_t, name C.struct_miqt_string) *C.QVariant { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(name string) *qt6.QVariant, name string) *qt6.QVariant) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var name_ms C.struct_miqt_string = name - name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) - C.free(unsafe.Pointer(name_ms.data)) - slotval1 := name_ret - - virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_ScxmlProperty, slotval1) - - return (*C.QVariant)(virtualReturn.UnsafePointer()) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_HasScxmlProperty(name string) bool { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - - return (bool)(C.QScxmlNullDataModel_virtualbase_hasScxmlProperty(unsafe.Pointer(this.h), name_ms)) - -} -func (this *QScxmlNullDataModel) OnHasScxmlProperty(slot func(super func(name string) bool, name string) bool) { - ok := C.QScxmlNullDataModel_override_virtual_hasScxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlNullDataModel_hasScxmlProperty -func miqt_exec_callback_QScxmlNullDataModel_hasScxmlProperty(self *C.QScxmlNullDataModel, cb C.intptr_t, name C.struct_miqt_string) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(name string) bool, name string) bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var name_ms C.struct_miqt_string = name - name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) - C.free(unsafe.Pointer(name_ms.data)) - slotval1 := name_ret - - virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_HasScxmlProperty, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_SetScxmlProperty(name string, value *qt6.QVariant, context string) bool { - name_ms := C.struct_miqt_string{} - name_ms.data = C.CString(name) - name_ms.len = C.size_t(len(name)) - defer C.free(unsafe.Pointer(name_ms.data)) - context_ms := C.struct_miqt_string{} - context_ms.data = C.CString(context) - context_ms.len = C.size_t(len(context)) - defer C.free(unsafe.Pointer(context_ms.data)) - - return (bool)(C.QScxmlNullDataModel_virtualbase_setScxmlProperty(unsafe.Pointer(this.h), name_ms, (*C.QVariant)(value.UnsafePointer()), context_ms)) - -} -func (this *QScxmlNullDataModel) OnSetScxmlProperty(slot func(super func(name string, value *qt6.QVariant, context string) bool, name string, value *qt6.QVariant, context string) bool) { - ok := C.QScxmlNullDataModel_override_virtual_setScxmlProperty(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) - if !ok { - panic("miqt: can only override virtual methods for directly constructed types") - } -} - -//export miqt_exec_callback_QScxmlNullDataModel_setScxmlProperty -func miqt_exec_callback_QScxmlNullDataModel_setScxmlProperty(self *C.QScxmlNullDataModel, cb C.intptr_t, name C.struct_miqt_string, value *C.QVariant, context C.struct_miqt_string) C.bool { - gofunc, ok := cgo.Handle(cb).Value().(func(super func(name string, value *qt6.QVariant, context string) bool, name string, value *qt6.QVariant, context string) bool) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var name_ms C.struct_miqt_string = name - name_ret := C.GoStringN(name_ms.data, C.int(int64(name_ms.len))) - C.free(unsafe.Pointer(name_ms.data)) - slotval1 := name_ret - slotval2 := qt6.UnsafeNewQVariant(unsafe.Pointer(value)) - - var context_ms C.struct_miqt_string = context - context_ret := C.GoStringN(context_ms.data, C.int(int64(context_ms.len))) - C.free(unsafe.Pointer(context_ms.data)) - slotval3 := context_ret - - virtualReturn := gofunc((&QScxmlNullDataModel{h: self}).callVirtualBase_SetScxmlProperty, slotval1, slotval2, slotval3) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_Event(event *qt6.QEvent) bool { - - return (bool)(C.QScxmlNullDataModel_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlNullDataModel) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { - ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_event -func miqt_exec_callback_QScxmlNullDataModel_event(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_Event, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { - - return (bool)(C.QScxmlNullDataModel_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) - -} -func (this *QScxmlNullDataModel) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { - ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_eventFilter -func miqt_exec_callback_QScxmlNullDataModel_eventFilter(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) - - return (C.bool)(virtualReturn) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { - - C.QScxmlNullDataModel_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) - -} -func (this *QScxmlNullDataModel) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { - ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_timerEvent -func miqt_exec_callback_QScxmlNullDataModel_timerEvent(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_TimerEvent, slotval1) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { - - C.QScxmlNullDataModel_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) - -} -func (this *QScxmlNullDataModel) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { - ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_childEvent -func miqt_exec_callback_QScxmlNullDataModel_childEvent(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_ChildEvent, slotval1) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_CustomEvent(event *qt6.QEvent) { - - C.QScxmlNullDataModel_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) - -} -func (this *QScxmlNullDataModel) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { - ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_customEvent -func miqt_exec_callback_QScxmlNullDataModel_customEvent(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_CustomEvent, slotval1) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlNullDataModel_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlNullDataModel) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_connectNotify -func miqt_exec_callback_QScxmlNullDataModel_connectNotify(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_ConnectNotify, slotval1) - -} - -func (this *QScxmlNullDataModel) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { - - C.QScxmlNullDataModel_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) - -} -func (this *QScxmlNullDataModel) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { - ok := C.QScxmlNullDataModel_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_QScxmlNullDataModel_disconnectNotify -func miqt_exec_callback_QScxmlNullDataModel_disconnectNotify(self *C.QScxmlNullDataModel, 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((&QScxmlNullDataModel{h: self}).callVirtualBase_DisconnectNotify, slotval1) - -} - -// Delete this object from C++ memory. -func (this *QScxmlNullDataModel) Delete() { - C.QScxmlNullDataModel_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 *QScxmlNullDataModel) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlNullDataModel) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} diff --git a/qt6/scxml/gen_qscxmlnulldatamodel.h b/qt6/scxml/gen_qscxmlnulldatamodel.h deleted file mode 100644 index 007d1b23d..000000000 --- a/qt6/scxml/gen_qscxmlnulldatamodel.h +++ /dev/null @@ -1,118 +0,0 @@ -#pragma once -#ifndef MIQT_QT6_SCXML_GEN_QSCXMLNULLDATAMODEL_H -#define MIQT_QT6_SCXML_GEN_QSCXMLNULLDATAMODEL_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 QScxmlDataModel; -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlDataModel__ForeachLoopBody) -typedef QScxmlDataModel::ForeachLoopBody QScxmlDataModel__ForeachLoopBody; -#else -class QScxmlDataModel__ForeachLoopBody; -#endif -class QScxmlEvent; -class QScxmlNullDataModel; -class QTimerEvent; -class QVariant; -#else -typedef struct QChildEvent QChildEvent; -typedef struct QEvent QEvent; -typedef struct QMetaMethod QMetaMethod; -typedef struct QMetaObject QMetaObject; -typedef struct QObject QObject; -typedef struct QScxmlDataModel QScxmlDataModel; -typedef struct QScxmlDataModel__ForeachLoopBody QScxmlDataModel__ForeachLoopBody; -typedef struct QScxmlEvent QScxmlEvent; -typedef struct QScxmlNullDataModel QScxmlNullDataModel; -typedef struct QTimerEvent QTimerEvent; -typedef struct QVariant QVariant; -#endif - -QScxmlNullDataModel* QScxmlNullDataModel_new(); -QScxmlNullDataModel* QScxmlNullDataModel_new2(QObject* parent); -void QScxmlNullDataModel_virtbase(QScxmlNullDataModel* src, QScxmlDataModel** outptr_QScxmlDataModel); -QMetaObject* QScxmlNullDataModel_metaObject(const QScxmlNullDataModel* self); -void* QScxmlNullDataModel_metacast(QScxmlNullDataModel* self, const char* param1); -struct miqt_string QScxmlNullDataModel_tr(const char* s); -bool QScxmlNullDataModel_setup(QScxmlNullDataModel* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); -struct miqt_string QScxmlNullDataModel_evaluateToString(QScxmlNullDataModel* self, int id, bool* ok); -bool QScxmlNullDataModel_evaluateToBool(QScxmlNullDataModel* self, int id, bool* ok); -QVariant* QScxmlNullDataModel_evaluateToVariant(QScxmlNullDataModel* self, int id, bool* ok); -void QScxmlNullDataModel_evaluateToVoid(QScxmlNullDataModel* self, int id, bool* ok); -void QScxmlNullDataModel_evaluateAssignment(QScxmlNullDataModel* self, int id, bool* ok); -void QScxmlNullDataModel_evaluateInitialization(QScxmlNullDataModel* self, int id, bool* ok); -void QScxmlNullDataModel_evaluateForeach(QScxmlNullDataModel* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); -void QScxmlNullDataModel_setScxmlEvent(QScxmlNullDataModel* self, QScxmlEvent* event); -QVariant* QScxmlNullDataModel_scxmlProperty(const QScxmlNullDataModel* self, struct miqt_string name); -bool QScxmlNullDataModel_hasScxmlProperty(const QScxmlNullDataModel* self, struct miqt_string name); -bool QScxmlNullDataModel_setScxmlProperty(QScxmlNullDataModel* self, struct miqt_string name, QVariant* value, struct miqt_string context); -struct miqt_string QScxmlNullDataModel_tr2(const char* s, const char* c); -struct miqt_string QScxmlNullDataModel_tr3(const char* s, const char* c, int n); - -bool QScxmlNullDataModel_override_virtual_setup(void* self, intptr_t slot); -bool QScxmlNullDataModel_virtualbase_setup(void* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialDataValues); -bool QScxmlNullDataModel_override_virtual_evaluateToString(void* self, intptr_t slot); -struct miqt_string QScxmlNullDataModel_virtualbase_evaluateToString(void* self, int id, bool* ok); -bool QScxmlNullDataModel_override_virtual_evaluateToBool(void* self, intptr_t slot); -bool QScxmlNullDataModel_virtualbase_evaluateToBool(void* self, int id, bool* ok); -bool QScxmlNullDataModel_override_virtual_evaluateToVariant(void* self, intptr_t slot); -QVariant* QScxmlNullDataModel_virtualbase_evaluateToVariant(void* self, int id, bool* ok); -bool QScxmlNullDataModel_override_virtual_evaluateToVoid(void* self, intptr_t slot); -void QScxmlNullDataModel_virtualbase_evaluateToVoid(void* self, int id, bool* ok); -bool QScxmlNullDataModel_override_virtual_evaluateAssignment(void* self, intptr_t slot); -void QScxmlNullDataModel_virtualbase_evaluateAssignment(void* self, int id, bool* ok); -bool QScxmlNullDataModel_override_virtual_evaluateInitialization(void* self, intptr_t slot); -void QScxmlNullDataModel_virtualbase_evaluateInitialization(void* self, int id, bool* ok); -bool QScxmlNullDataModel_override_virtual_evaluateForeach(void* self, intptr_t slot); -void QScxmlNullDataModel_virtualbase_evaluateForeach(void* self, int id, bool* ok, QScxmlDataModel__ForeachLoopBody* body); -bool QScxmlNullDataModel_override_virtual_setScxmlEvent(void* self, intptr_t slot); -void QScxmlNullDataModel_virtualbase_setScxmlEvent(void* self, QScxmlEvent* event); -bool QScxmlNullDataModel_override_virtual_scxmlProperty(void* self, intptr_t slot); -QVariant* QScxmlNullDataModel_virtualbase_scxmlProperty(const void* self, struct miqt_string name); -bool QScxmlNullDataModel_override_virtual_hasScxmlProperty(void* self, intptr_t slot); -bool QScxmlNullDataModel_virtualbase_hasScxmlProperty(const void* self, struct miqt_string name); -bool QScxmlNullDataModel_override_virtual_setScxmlProperty(void* self, intptr_t slot); -bool QScxmlNullDataModel_virtualbase_setScxmlProperty(void* self, struct miqt_string name, QVariant* value, struct miqt_string context); -bool QScxmlNullDataModel_override_virtual_event(void* self, intptr_t slot); -bool QScxmlNullDataModel_virtualbase_event(void* self, QEvent* event); -bool QScxmlNullDataModel_override_virtual_eventFilter(void* self, intptr_t slot); -bool QScxmlNullDataModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); -bool QScxmlNullDataModel_override_virtual_timerEvent(void* self, intptr_t slot); -void QScxmlNullDataModel_virtualbase_timerEvent(void* self, QTimerEvent* event); -bool QScxmlNullDataModel_override_virtual_childEvent(void* self, intptr_t slot); -void QScxmlNullDataModel_virtualbase_childEvent(void* self, QChildEvent* event); -bool QScxmlNullDataModel_override_virtual_customEvent(void* self, intptr_t slot); -void QScxmlNullDataModel_virtualbase_customEvent(void* self, QEvent* event); -bool QScxmlNullDataModel_override_virtual_connectNotify(void* self, intptr_t slot); -void QScxmlNullDataModel_virtualbase_connectNotify(void* self, QMetaMethod* signal); -bool QScxmlNullDataModel_override_virtual_disconnectNotify(void* self, intptr_t slot); -void QScxmlNullDataModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - -QObject* QScxmlNullDataModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); -int QScxmlNullDataModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); -int QScxmlNullDataModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); -bool QScxmlNullDataModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); - -void QScxmlNullDataModel_delete(QScxmlNullDataModel* self); - -#ifdef __cplusplus -} /* extern C */ -#endif - -#endif diff --git a/qt6/scxml/gen_qscxmlstatemachine.cpp b/qt6/scxml/gen_qscxmlstatemachine.cpp deleted file mode 100644 index f541a0d0b..000000000 --- a/qt6/scxml/gen_qscxmlstatemachine.cpp +++ /dev/null @@ -1,535 +0,0 @@ -#include -#include -#include -#include -#include -#define WORKAROUND_INNER_CLASS_DEFINITION_QMetaObject__Connection -#include -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlCompiler__Loader -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "gen_qscxmlstatemachine.h" - -#ifdef __cplusplus -extern "C" { -#endif - -void miqt_exec_callback_QScxmlStateMachine_runningChanged(intptr_t, bool); -void miqt_exec_callback_QScxmlStateMachine_invokedServicesChanged(intptr_t, struct miqt_array /* of QScxmlInvokableService* */ ); -void miqt_exec_callback_QScxmlStateMachine_log(intptr_t, struct miqt_string, struct miqt_string); -void miqt_exec_callback_QScxmlStateMachine_reachedStableState(intptr_t); -void miqt_exec_callback_QScxmlStateMachine_finished(intptr_t); -void miqt_exec_callback_QScxmlStateMachine_dataModelChanged(intptr_t, QScxmlDataModel*); -void miqt_exec_callback_QScxmlStateMachine_initialValuesChanged(intptr_t, struct miqt_map /* of struct miqt_string to QVariant* */ ); -void miqt_exec_callback_QScxmlStateMachine_initializedChanged(intptr_t, bool); -void miqt_exec_callback_QScxmlStateMachine_loaderChanged(intptr_t, QScxmlCompiler__Loader*); -void miqt_exec_callback_QScxmlStateMachine_tableDataChanged(intptr_t, QScxmlTableData*); -#ifdef __cplusplus -} /* extern C */ -#endif - -void QScxmlStateMachine_virtbase(QScxmlStateMachine* src, QObject** outptr_QObject) { - *outptr_QObject = static_cast(src); -} - -QMetaObject* QScxmlStateMachine_metaObject(const QScxmlStateMachine* self) { - return (QMetaObject*) self->metaObject(); -} - -void* QScxmlStateMachine_metacast(QScxmlStateMachine* self, const char* param1) { - return self->qt_metacast(param1); -} - -struct miqt_string QScxmlStateMachine_tr(const char* s) { - QString _ret = QScxmlStateMachine::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; -} - -QScxmlStateMachine* QScxmlStateMachine_fromFile(struct miqt_string fileName) { - QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); - return QScxmlStateMachine::fromFile(fileName_QString); -} - -QScxmlStateMachine* QScxmlStateMachine_fromData(QIODevice* data) { - return QScxmlStateMachine::fromData(data); -} - -struct miqt_array /* of QScxmlError* */ QScxmlStateMachine_parseErrors(const QScxmlStateMachine* self) { - QList _ret = self->parseErrors(); - // Convert QList<> from C++ memory to manually-managed C memory - QScxmlError** _arr = static_cast(malloc(sizeof(QScxmlError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { - _arr[i] = new QScxmlError(_ret[i]); - } - struct miqt_array _out; - _out.len = _ret.length(); - _out.data = static_cast(_arr); - return _out; -} - -struct miqt_string QScxmlStateMachine_sessionId(const QScxmlStateMachine* self) { - QString _ret = self->sessionId(); - // 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 QScxmlStateMachine_isInvoked(const QScxmlStateMachine* self) { - return self->isInvoked(); -} - -bool QScxmlStateMachine_isInitialized(const QScxmlStateMachine* self) { - return self->isInitialized(); -} - -void QScxmlStateMachine_setDataModel(QScxmlStateMachine* self, QScxmlDataModel* model) { - self->setDataModel(model); -} - -QScxmlDataModel* QScxmlStateMachine_dataModel(const QScxmlStateMachine* self) { - return self->dataModel(); -} - -void QScxmlStateMachine_setLoader(QScxmlStateMachine* self, QScxmlCompiler__Loader* loader) { - self->setLoader(loader); -} - -QScxmlCompiler__Loader* QScxmlStateMachine_loader(const QScxmlStateMachine* self) { - return self->loader(); -} - -bool QScxmlStateMachine_isRunning(const QScxmlStateMachine* self) { - return self->isRunning(); -} - -void QScxmlStateMachine_setRunning(QScxmlStateMachine* self, bool running) { - self->setRunning(running); -} - -struct miqt_map /* of struct miqt_string to QVariant* */ QScxmlStateMachine_initialValues(QScxmlStateMachine* self) { - QVariantMap _ret = self->initialValues(); - // Convert QMap<> from C++ memory to manually-managed C memory - struct miqt_string* _karr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); - QVariant** _varr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); - int _ctr = 0; - for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) { - QString _mapkey_ret = _itr->first; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray _mapkey_b = _mapkey_ret.toUtf8(); - struct miqt_string _mapkey_ms; - _mapkey_ms.len = _mapkey_b.length(); - _mapkey_ms.data = static_cast(malloc(_mapkey_ms.len)); - memcpy(_mapkey_ms.data, _mapkey_b.data(), _mapkey_ms.len); - _karr[_ctr] = _mapkey_ms; - _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; -} - -void QScxmlStateMachine_setInitialValues(QScxmlStateMachine* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialValues) { - QVariantMap initialValues_QMap; - struct miqt_string* initialValues_karr = static_cast(initialValues.keys); - QVariant** initialValues_varr = static_cast(initialValues.values); - for(size_t i = 0; i < initialValues.len; ++i) { - QString initialValues_karr_i_QString = QString::fromUtf8(initialValues_karr[i].data, initialValues_karr[i].len); - initialValues_QMap[initialValues_karr_i_QString] = *(initialValues_varr[i]); - } - self->setInitialValues(initialValues_QMap); -} - -struct miqt_string QScxmlStateMachine_name(const QScxmlStateMachine* self) { - QString _ret = self->name(); - // 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 struct miqt_string */ QScxmlStateMachine_stateNames(const QScxmlStateMachine* self) { - QStringList _ret = self->stateNames(); - // 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; -} - -struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_activeStateNames(const QScxmlStateMachine* self) { - QStringList _ret = self->activeStateNames(); - // 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 QScxmlStateMachine_isActive(const QScxmlStateMachine* self, struct miqt_string scxmlStateName) { - QString scxmlStateName_QString = QString::fromUtf8(scxmlStateName.data, scxmlStateName.len); - return self->isActive(scxmlStateName_QString); -} - -QMetaObject__Connection* QScxmlStateMachine_connectToState(QScxmlStateMachine* self, struct miqt_string scxmlStateName, QObject* receiver, const char* method) { - QString scxmlStateName_QString = QString::fromUtf8(scxmlStateName.data, scxmlStateName.len); - return new QMetaObject::Connection(self->connectToState(scxmlStateName_QString, receiver, method)); -} - -QMetaObject__Connection* QScxmlStateMachine_connectToEvent(QScxmlStateMachine* self, struct miqt_string scxmlEventSpec, QObject* receiver, const char* method) { - QString scxmlEventSpec_QString = QString::fromUtf8(scxmlEventSpec.data, scxmlEventSpec.len); - return new QMetaObject::Connection(self->connectToEvent(scxmlEventSpec_QString, receiver, method)); -} - -void QScxmlStateMachine_submitEvent(QScxmlStateMachine* self, QScxmlEvent* event) { - self->submitEvent(event); -} - -void QScxmlStateMachine_submitEventWithEventName(QScxmlStateMachine* self, struct miqt_string eventName) { - QString eventName_QString = QString::fromUtf8(eventName.data, eventName.len); - self->submitEvent(eventName_QString); -} - -void QScxmlStateMachine_submitEvent2(QScxmlStateMachine* self, struct miqt_string eventName, QVariant* data) { - QString eventName_QString = QString::fromUtf8(eventName.data, eventName.len); - self->submitEvent(eventName_QString, *data); -} - -void QScxmlStateMachine_cancelDelayedEvent(QScxmlStateMachine* self, struct miqt_string sendId) { - QString sendId_QString = QString::fromUtf8(sendId.data, sendId.len); - self->cancelDelayedEvent(sendId_QString); -} - -bool QScxmlStateMachine_isDispatchableTarget(const QScxmlStateMachine* self, struct miqt_string target) { - QString target_QString = QString::fromUtf8(target.data, target.len); - return self->isDispatchableTarget(target_QString); -} - -struct miqt_array /* of QScxmlInvokableService* */ QScxmlStateMachine_invokedServices(const QScxmlStateMachine* self) { - QList _ret = self->invokedServices(); - // Convert QList<> from C++ memory to manually-managed C memory - QScxmlInvokableService** _arr = static_cast(malloc(sizeof(QScxmlInvokableService*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { - _arr[i] = _ret[i]; - } - struct miqt_array _out; - _out.len = _ret.length(); - _out.data = static_cast(_arr); - return _out; -} - -QScxmlTableData* QScxmlStateMachine_tableData(const QScxmlStateMachine* self) { - return self->tableData(); -} - -void QScxmlStateMachine_setTableData(QScxmlStateMachine* self, QScxmlTableData* tableData) { - self->setTableData(tableData); -} - -void QScxmlStateMachine_runningChanged(QScxmlStateMachine* self, bool running) { - self->runningChanged(running); -} - -void QScxmlStateMachine_connect_runningChanged(QScxmlStateMachine* self, intptr_t slot) { - QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::runningChanged), self, [=](bool running) { - bool sigval1 = running; - miqt_exec_callback_QScxmlStateMachine_runningChanged(slot, sigval1); - }); -} - -void QScxmlStateMachine_invokedServicesChanged(QScxmlStateMachine* self, struct miqt_array /* of QScxmlInvokableService* */ invokedServices) { - QList invokedServices_QList; - invokedServices_QList.reserve(invokedServices.len); - QScxmlInvokableService** invokedServices_arr = static_cast(invokedServices.data); - for(size_t i = 0; i < invokedServices.len; ++i) { - invokedServices_QList.push_back(invokedServices_arr[i]); - } - self->invokedServicesChanged(invokedServices_QList); -} - -void QScxmlStateMachine_connect_invokedServicesChanged(QScxmlStateMachine* self, intptr_t slot) { - QScxmlStateMachine::connect(self, static_cast&)>(&QScxmlStateMachine::invokedServicesChanged), self, [=](const QList& invokedServices) { - const QList& invokedServices_ret = invokedServices; - // Convert QList<> from C++ memory to manually-managed C memory - QScxmlInvokableService** invokedServices_arr = static_cast(malloc(sizeof(QScxmlInvokableService*) * invokedServices_ret.length())); - for (size_t i = 0, e = invokedServices_ret.length(); i < e; ++i) { - invokedServices_arr[i] = invokedServices_ret[i]; - } - struct miqt_array invokedServices_out; - invokedServices_out.len = invokedServices_ret.length(); - invokedServices_out.data = static_cast(invokedServices_arr); - struct miqt_array /* of QScxmlInvokableService* */ sigval1 = invokedServices_out; - miqt_exec_callback_QScxmlStateMachine_invokedServicesChanged(slot, sigval1); - }); -} - -void QScxmlStateMachine_log(QScxmlStateMachine* self, struct miqt_string label, struct miqt_string msg) { - QString label_QString = QString::fromUtf8(label.data, label.len); - QString msg_QString = QString::fromUtf8(msg.data, msg.len); - self->log(label_QString, msg_QString); -} - -void QScxmlStateMachine_connect_log(QScxmlStateMachine* self, intptr_t slot) { - QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::log), self, [=](const QString& label, const QString& msg) { - const QString label_ret = label; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray label_b = label_ret.toUtf8(); - struct miqt_string label_ms; - label_ms.len = label_b.length(); - label_ms.data = static_cast(malloc(label_ms.len)); - memcpy(label_ms.data, label_b.data(), label_ms.len); - struct miqt_string sigval1 = label_ms; - const QString msg_ret = msg; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray msg_b = msg_ret.toUtf8(); - struct miqt_string msg_ms; - msg_ms.len = msg_b.length(); - msg_ms.data = static_cast(malloc(msg_ms.len)); - memcpy(msg_ms.data, msg_b.data(), msg_ms.len); - struct miqt_string sigval2 = msg_ms; - miqt_exec_callback_QScxmlStateMachine_log(slot, sigval1, sigval2); - }); -} - -void QScxmlStateMachine_reachedStableState(QScxmlStateMachine* self) { - self->reachedStableState(); -} - -void QScxmlStateMachine_connect_reachedStableState(QScxmlStateMachine* self, intptr_t slot) { - QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::reachedStableState), self, [=]() { - miqt_exec_callback_QScxmlStateMachine_reachedStableState(slot); - }); -} - -void QScxmlStateMachine_finished(QScxmlStateMachine* self) { - self->finished(); -} - -void QScxmlStateMachine_connect_finished(QScxmlStateMachine* self, intptr_t slot) { - QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::finished), self, [=]() { - miqt_exec_callback_QScxmlStateMachine_finished(slot); - }); -} - -void QScxmlStateMachine_dataModelChanged(QScxmlStateMachine* self, QScxmlDataModel* model) { - self->dataModelChanged(model); -} - -void QScxmlStateMachine_connect_dataModelChanged(QScxmlStateMachine* self, intptr_t slot) { - QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::dataModelChanged), self, [=](QScxmlDataModel* model) { - QScxmlDataModel* sigval1 = model; - miqt_exec_callback_QScxmlStateMachine_dataModelChanged(slot, sigval1); - }); -} - -void QScxmlStateMachine_initialValuesChanged(QScxmlStateMachine* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialValues) { - QVariantMap initialValues_QMap; - struct miqt_string* initialValues_karr = static_cast(initialValues.keys); - QVariant** initialValues_varr = static_cast(initialValues.values); - for(size_t i = 0; i < initialValues.len; ++i) { - QString initialValues_karr_i_QString = QString::fromUtf8(initialValues_karr[i].data, initialValues_karr[i].len); - initialValues_QMap[initialValues_karr_i_QString] = *(initialValues_varr[i]); - } - self->initialValuesChanged(initialValues_QMap); -} - -void QScxmlStateMachine_connect_initialValuesChanged(QScxmlStateMachine* self, intptr_t slot) { - QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::initialValuesChanged), self, [=](const QVariantMap& initialValues) { - const QVariantMap& initialValues_ret = initialValues; - // Convert QMap<> from C++ memory to manually-managed C memory - struct miqt_string* initialValues_karr = static_cast(malloc(sizeof(struct miqt_string) * initialValues_ret.size())); - QVariant** initialValues_varr = static_cast(malloc(sizeof(QVariant*) * initialValues_ret.size())); - int initialValues_ctr = 0; - for (auto initialValues_itr = initialValues_ret.keyValueBegin(); initialValues_itr != initialValues_ret.keyValueEnd(); ++initialValues_itr) { - QString initialValues_mapkey_ret = initialValues_itr->first; - // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory - QByteArray initialValues_mapkey_b = initialValues_mapkey_ret.toUtf8(); - struct miqt_string initialValues_mapkey_ms; - initialValues_mapkey_ms.len = initialValues_mapkey_b.length(); - initialValues_mapkey_ms.data = static_cast(malloc(initialValues_mapkey_ms.len)); - memcpy(initialValues_mapkey_ms.data, initialValues_mapkey_b.data(), initialValues_mapkey_ms.len); - initialValues_karr[initialValues_ctr] = initialValues_mapkey_ms; - initialValues_varr[initialValues_ctr] = new QVariant(initialValues_itr->second); - initialValues_ctr++; - } - struct miqt_map initialValues_out; - initialValues_out.len = initialValues_ret.size(); - initialValues_out.keys = static_cast(initialValues_karr); - initialValues_out.values = static_cast(initialValues_varr); - struct miqt_map /* of struct miqt_string to QVariant* */ sigval1 = initialValues_out; - miqt_exec_callback_QScxmlStateMachine_initialValuesChanged(slot, sigval1); - }); -} - -void QScxmlStateMachine_initializedChanged(QScxmlStateMachine* self, bool initialized) { - self->initializedChanged(initialized); -} - -void QScxmlStateMachine_connect_initializedChanged(QScxmlStateMachine* self, intptr_t slot) { - QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::initializedChanged), self, [=](bool initialized) { - bool sigval1 = initialized; - miqt_exec_callback_QScxmlStateMachine_initializedChanged(slot, sigval1); - }); -} - -void QScxmlStateMachine_loaderChanged(QScxmlStateMachine* self, QScxmlCompiler__Loader* loader) { - self->loaderChanged(loader); -} - -void QScxmlStateMachine_connect_loaderChanged(QScxmlStateMachine* self, intptr_t slot) { - QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::loaderChanged), self, [=](QScxmlCompiler::Loader* loader) { - QScxmlCompiler__Loader* sigval1 = loader; - miqt_exec_callback_QScxmlStateMachine_loaderChanged(slot, sigval1); - }); -} - -void QScxmlStateMachine_tableDataChanged(QScxmlStateMachine* self, QScxmlTableData* tableData) { - self->tableDataChanged(tableData); -} - -void QScxmlStateMachine_connect_tableDataChanged(QScxmlStateMachine* self, intptr_t slot) { - QScxmlStateMachine::connect(self, static_cast(&QScxmlStateMachine::tableDataChanged), self, [=](QScxmlTableData* tableData) { - QScxmlTableData* sigval1 = tableData; - miqt_exec_callback_QScxmlStateMachine_tableDataChanged(slot, sigval1); - }); -} - -void QScxmlStateMachine_start(QScxmlStateMachine* self) { - self->start(); -} - -void QScxmlStateMachine_stop(QScxmlStateMachine* self) { - self->stop(); -} - -bool QScxmlStateMachine_init(QScxmlStateMachine* self) { - return self->init(); -} - -struct miqt_string QScxmlStateMachine_tr2(const char* s, const char* c) { - QString _ret = QScxmlStateMachine::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 QScxmlStateMachine_tr3(const char* s, const char* c, int n) { - QString _ret = QScxmlStateMachine::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; -} - -QScxmlStateMachine* QScxmlStateMachine_fromData2(QIODevice* data, struct miqt_string fileName) { - QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); - return QScxmlStateMachine::fromData(data, fileName_QString); -} - -struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_stateNamesWithCompress(const QScxmlStateMachine* self, bool compress) { - QStringList _ret = self->stateNames(compress); - // 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; -} - -struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_activeStateNamesWithCompress(const QScxmlStateMachine* self, bool compress) { - QStringList _ret = self->activeStateNames(compress); - // 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; -} - -QMetaObject__Connection* QScxmlStateMachine_connectToState2(QScxmlStateMachine* self, struct miqt_string scxmlStateName, QObject* receiver, const char* method, int type) { - QString scxmlStateName_QString = QString::fromUtf8(scxmlStateName.data, scxmlStateName.len); - return new QMetaObject::Connection(self->connectToState(scxmlStateName_QString, receiver, method, static_cast(type))); -} - -QMetaObject__Connection* QScxmlStateMachine_connectToEvent2(QScxmlStateMachine* self, struct miqt_string scxmlEventSpec, QObject* receiver, const char* method, int type) { - QString scxmlEventSpec_QString = QString::fromUtf8(scxmlEventSpec.data, scxmlEventSpec.len); - return new QMetaObject::Connection(self->connectToEvent(scxmlEventSpec_QString, receiver, method, static_cast(type))); -} - -void QScxmlStateMachine_delete(QScxmlStateMachine* self) { - delete self; -} - diff --git a/qt6/scxml/gen_qscxmlstatemachine.go b/qt6/scxml/gen_qscxmlstatemachine.go deleted file mode 100644 index 91ff31a35..000000000 --- a/qt6/scxml/gen_qscxmlstatemachine.go +++ /dev/null @@ -1,656 +0,0 @@ -package scxml - -/* - -#include "gen_qscxmlstatemachine.h" -#include - -*/ -import "C" - -import ( - "github.com/mappu/miqt/qt6" - "runtime" - "runtime/cgo" - "unsafe" -) - -type QScxmlStateMachine struct { - h *C.QScxmlStateMachine - *qt6.QObject -} - -func (this *QScxmlStateMachine) cPointer() *C.QScxmlStateMachine { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlStateMachine) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlStateMachine constructs the type using only CGO pointers. -func newQScxmlStateMachine(h *C.QScxmlStateMachine) *QScxmlStateMachine { - if h == nil { - return nil - } - var outptr_QObject *C.QObject = nil - C.QScxmlStateMachine_virtbase(h, &outptr_QObject) - - return &QScxmlStateMachine{h: h, - QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} -} - -// UnsafeNewQScxmlStateMachine constructs the type using only unsafe pointers. -func UnsafeNewQScxmlStateMachine(h unsafe.Pointer) *QScxmlStateMachine { - return newQScxmlStateMachine((*C.QScxmlStateMachine)(h)) -} - -func (this *QScxmlStateMachine) MetaObject() *qt6.QMetaObject { - return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QScxmlStateMachine_metaObject(this.h))) -} - -func (this *QScxmlStateMachine) Metacast(param1 string) unsafe.Pointer { - param1_Cstring := C.CString(param1) - defer C.free(unsafe.Pointer(param1_Cstring)) - return (unsafe.Pointer)(C.QScxmlStateMachine_metacast(this.h, param1_Cstring)) -} - -func QScxmlStateMachine_Tr(s string) string { - s_Cstring := C.CString(s) - defer C.free(unsafe.Pointer(s_Cstring)) - var _ms C.struct_miqt_string = C.QScxmlStateMachine_tr(s_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func QScxmlStateMachine_FromFile(fileName string) *QScxmlStateMachine { - 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 newQScxmlStateMachine(C.QScxmlStateMachine_fromFile(fileName_ms)) -} - -func QScxmlStateMachine_FromData(data *qt6.QIODevice) *QScxmlStateMachine { - return newQScxmlStateMachine(C.QScxmlStateMachine_fromData((*C.QIODevice)(data.UnsafePointer()))) -} - -func (this *QScxmlStateMachine) ParseErrors() []QScxmlError { - var _ma C.struct_miqt_array = C.QScxmlStateMachine_parseErrors(this.h) - _ret := make([]QScxmlError, int(_ma.len)) - _outCast := (*[0xffff]*C.QScxmlError)(unsafe.Pointer(_ma.data)) // hey ya - for i := 0; i < int(_ma.len); i++ { - _lv_goptr := newQScxmlError(_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 *QScxmlStateMachine) SessionId() string { - var _ms C.struct_miqt_string = C.QScxmlStateMachine_sessionId(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlStateMachine) IsInvoked() bool { - return (bool)(C.QScxmlStateMachine_isInvoked(this.h)) -} - -func (this *QScxmlStateMachine) IsInitialized() bool { - return (bool)(C.QScxmlStateMachine_isInitialized(this.h)) -} - -func (this *QScxmlStateMachine) SetDataModel(model *QScxmlDataModel) { - C.QScxmlStateMachine_setDataModel(this.h, model.cPointer()) -} - -func (this *QScxmlStateMachine) DataModel() *QScxmlDataModel { - return newQScxmlDataModel(C.QScxmlStateMachine_dataModel(this.h)) -} - -func (this *QScxmlStateMachine) SetLoader(loader *QScxmlCompiler__Loader) { - C.QScxmlStateMachine_setLoader(this.h, loader.cPointer()) -} - -func (this *QScxmlStateMachine) Loader() *QScxmlCompiler__Loader { - return newQScxmlCompiler__Loader(C.QScxmlStateMachine_loader(this.h)) -} - -func (this *QScxmlStateMachine) IsRunning() bool { - return (bool)(C.QScxmlStateMachine_isRunning(this.h)) -} - -func (this *QScxmlStateMachine) SetRunning(running bool) { - C.QScxmlStateMachine_setRunning(this.h, (C.bool)(running)) -} - -func (this *QScxmlStateMachine) InitialValues() map[string]qt6.QVariant { - var _mm C.struct_miqt_map = C.QScxmlStateMachine_initialValues(this.h) - _ret := make(map[string]qt6.QVariant, int(_mm.len)) - _Keys := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_mm.keys)) - _Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(_mm.values)) - for i := 0; i < int(_mm.len); i++ { - var _mapkey_ms C.struct_miqt_string = _Keys[i] - _mapkey_ret := C.GoStringN(_mapkey_ms.data, C.int(int64(_mapkey_ms.len))) - C.free(unsafe.Pointer(_mapkey_ms.data)) - _entry_Key := _mapkey_ret - _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 *QScxmlStateMachine) SetInitialValues(initialValues map[string]qt6.QVariant) { - initialValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialValues)))) - defer C.free(unsafe.Pointer(initialValues_Keys_CArray)) - initialValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialValues)))) - defer C.free(unsafe.Pointer(initialValues_Values_CArray)) - initialValues_ctr := 0 - for initialValues_k, initialValues_v := range initialValues { - initialValues_k_ms := C.struct_miqt_string{} - initialValues_k_ms.data = C.CString(initialValues_k) - initialValues_k_ms.len = C.size_t(len(initialValues_k)) - defer C.free(unsafe.Pointer(initialValues_k_ms.data)) - initialValues_Keys_CArray[initialValues_ctr] = initialValues_k_ms - initialValues_Values_CArray[initialValues_ctr] = (*C.QVariant)(initialValues_v.UnsafePointer()) - initialValues_ctr++ - } - initialValues_mm := C.struct_miqt_map{ - len: C.size_t(len(initialValues)), - keys: unsafe.Pointer(initialValues_Keys_CArray), - values: unsafe.Pointer(initialValues_Values_CArray), - } - C.QScxmlStateMachine_setInitialValues(this.h, initialValues_mm) -} - -func (this *QScxmlStateMachine) Name() string { - var _ms C.struct_miqt_string = C.QScxmlStateMachine_name(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlStateMachine) StateNames() []string { - var _ma C.struct_miqt_array = C.QScxmlStateMachine_stateNames(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 *QScxmlStateMachine) ActiveStateNames() []string { - var _ma C.struct_miqt_array = C.QScxmlStateMachine_activeStateNames(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 *QScxmlStateMachine) IsActive(scxmlStateName string) bool { - scxmlStateName_ms := C.struct_miqt_string{} - scxmlStateName_ms.data = C.CString(scxmlStateName) - scxmlStateName_ms.len = C.size_t(len(scxmlStateName)) - defer C.free(unsafe.Pointer(scxmlStateName_ms.data)) - return (bool)(C.QScxmlStateMachine_isActive(this.h, scxmlStateName_ms)) -} - -func (this *QScxmlStateMachine) ConnectToState(scxmlStateName string, receiver *qt6.QObject, method string) *qt6.QMetaObject__Connection { - scxmlStateName_ms := C.struct_miqt_string{} - scxmlStateName_ms.data = C.CString(scxmlStateName) - scxmlStateName_ms.len = C.size_t(len(scxmlStateName)) - defer C.free(unsafe.Pointer(scxmlStateName_ms.data)) - method_Cstring := C.CString(method) - defer C.free(unsafe.Pointer(method_Cstring)) - _goptr := qt6.UnsafeNewQMetaObject__Connection(unsafe.Pointer(C.QScxmlStateMachine_connectToState(this.h, scxmlStateName_ms, (*C.QObject)(receiver.UnsafePointer()), method_Cstring))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -func (this *QScxmlStateMachine) ConnectToEvent(scxmlEventSpec string, receiver *qt6.QObject, method string) *qt6.QMetaObject__Connection { - scxmlEventSpec_ms := C.struct_miqt_string{} - scxmlEventSpec_ms.data = C.CString(scxmlEventSpec) - scxmlEventSpec_ms.len = C.size_t(len(scxmlEventSpec)) - defer C.free(unsafe.Pointer(scxmlEventSpec_ms.data)) - method_Cstring := C.CString(method) - defer C.free(unsafe.Pointer(method_Cstring)) - _goptr := qt6.UnsafeNewQMetaObject__Connection(unsafe.Pointer(C.QScxmlStateMachine_connectToEvent(this.h, scxmlEventSpec_ms, (*C.QObject)(receiver.UnsafePointer()), method_Cstring))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -func (this *QScxmlStateMachine) SubmitEvent(event *QScxmlEvent) { - C.QScxmlStateMachine_submitEvent(this.h, event.cPointer()) -} - -func (this *QScxmlStateMachine) SubmitEventWithEventName(eventName string) { - eventName_ms := C.struct_miqt_string{} - eventName_ms.data = C.CString(eventName) - eventName_ms.len = C.size_t(len(eventName)) - defer C.free(unsafe.Pointer(eventName_ms.data)) - C.QScxmlStateMachine_submitEventWithEventName(this.h, eventName_ms) -} - -func (this *QScxmlStateMachine) SubmitEvent2(eventName string, data *qt6.QVariant) { - eventName_ms := C.struct_miqt_string{} - eventName_ms.data = C.CString(eventName) - eventName_ms.len = C.size_t(len(eventName)) - defer C.free(unsafe.Pointer(eventName_ms.data)) - C.QScxmlStateMachine_submitEvent2(this.h, eventName_ms, (*C.QVariant)(data.UnsafePointer())) -} - -func (this *QScxmlStateMachine) CancelDelayedEvent(sendId string) { - sendId_ms := C.struct_miqt_string{} - sendId_ms.data = C.CString(sendId) - sendId_ms.len = C.size_t(len(sendId)) - defer C.free(unsafe.Pointer(sendId_ms.data)) - C.QScxmlStateMachine_cancelDelayedEvent(this.h, sendId_ms) -} - -func (this *QScxmlStateMachine) IsDispatchableTarget(target string) bool { - target_ms := C.struct_miqt_string{} - target_ms.data = C.CString(target) - target_ms.len = C.size_t(len(target)) - defer C.free(unsafe.Pointer(target_ms.data)) - return (bool)(C.QScxmlStateMachine_isDispatchableTarget(this.h, target_ms)) -} - -func (this *QScxmlStateMachine) InvokedServices() []*QScxmlInvokableService { - var _ma C.struct_miqt_array = C.QScxmlStateMachine_invokedServices(this.h) - _ret := make([]*QScxmlInvokableService, int(_ma.len)) - _outCast := (*[0xffff]*C.QScxmlInvokableService)(unsafe.Pointer(_ma.data)) // hey ya - for i := 0; i < int(_ma.len); i++ { - _ret[i] = newQScxmlInvokableService(_outCast[i]) - } - return _ret -} - -func (this *QScxmlStateMachine) TableData() *QScxmlTableData { - return newQScxmlTableData(C.QScxmlStateMachine_tableData(this.h)) -} - -func (this *QScxmlStateMachine) SetTableData(tableData *QScxmlTableData) { - C.QScxmlStateMachine_setTableData(this.h, tableData.cPointer()) -} - -func (this *QScxmlStateMachine) RunningChanged(running bool) { - C.QScxmlStateMachine_runningChanged(this.h, (C.bool)(running)) -} -func (this *QScxmlStateMachine) OnRunningChanged(slot func(running bool)) { - C.QScxmlStateMachine_connect_runningChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) -} - -//export miqt_exec_callback_QScxmlStateMachine_runningChanged -func miqt_exec_callback_QScxmlStateMachine_runningChanged(cb C.intptr_t, running C.bool) { - gofunc, ok := cgo.Handle(cb).Value().(func(running bool)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (bool)(running) - - gofunc(slotval1) -} - -func (this *QScxmlStateMachine) InvokedServicesChanged(invokedServices []*QScxmlInvokableService) { - invokedServices_CArray := (*[0xffff]*C.QScxmlInvokableService)(C.malloc(C.size_t(8 * len(invokedServices)))) - defer C.free(unsafe.Pointer(invokedServices_CArray)) - for i := range invokedServices { - invokedServices_CArray[i] = invokedServices[i].cPointer() - } - invokedServices_ma := C.struct_miqt_array{len: C.size_t(len(invokedServices)), data: unsafe.Pointer(invokedServices_CArray)} - C.QScxmlStateMachine_invokedServicesChanged(this.h, invokedServices_ma) -} -func (this *QScxmlStateMachine) OnInvokedServicesChanged(slot func(invokedServices []*QScxmlInvokableService)) { - C.QScxmlStateMachine_connect_invokedServicesChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) -} - -//export miqt_exec_callback_QScxmlStateMachine_invokedServicesChanged -func miqt_exec_callback_QScxmlStateMachine_invokedServicesChanged(cb C.intptr_t, invokedServices C.struct_miqt_array) { - gofunc, ok := cgo.Handle(cb).Value().(func(invokedServices []*QScxmlInvokableService)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var invokedServices_ma C.struct_miqt_array = invokedServices - invokedServices_ret := make([]*QScxmlInvokableService, int(invokedServices_ma.len)) - invokedServices_outCast := (*[0xffff]*C.QScxmlInvokableService)(unsafe.Pointer(invokedServices_ma.data)) // hey ya - for i := 0; i < int(invokedServices_ma.len); i++ { - invokedServices_ret[i] = newQScxmlInvokableService(invokedServices_outCast[i]) - } - slotval1 := invokedServices_ret - - gofunc(slotval1) -} - -func (this *QScxmlStateMachine) Log(label string, msg string) { - label_ms := C.struct_miqt_string{} - label_ms.data = C.CString(label) - label_ms.len = C.size_t(len(label)) - defer C.free(unsafe.Pointer(label_ms.data)) - msg_ms := C.struct_miqt_string{} - msg_ms.data = C.CString(msg) - msg_ms.len = C.size_t(len(msg)) - defer C.free(unsafe.Pointer(msg_ms.data)) - C.QScxmlStateMachine_log(this.h, label_ms, msg_ms) -} -func (this *QScxmlStateMachine) OnLog(slot func(label string, msg string)) { - C.QScxmlStateMachine_connect_log(this.h, C.intptr_t(cgo.NewHandle(slot))) -} - -//export miqt_exec_callback_QScxmlStateMachine_log -func miqt_exec_callback_QScxmlStateMachine_log(cb C.intptr_t, label C.struct_miqt_string, msg C.struct_miqt_string) { - gofunc, ok := cgo.Handle(cb).Value().(func(label string, msg string)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var label_ms C.struct_miqt_string = label - label_ret := C.GoStringN(label_ms.data, C.int(int64(label_ms.len))) - C.free(unsafe.Pointer(label_ms.data)) - slotval1 := label_ret - var msg_ms C.struct_miqt_string = msg - msg_ret := C.GoStringN(msg_ms.data, C.int(int64(msg_ms.len))) - C.free(unsafe.Pointer(msg_ms.data)) - slotval2 := msg_ret - - gofunc(slotval1, slotval2) -} - -func (this *QScxmlStateMachine) ReachedStableState() { - C.QScxmlStateMachine_reachedStableState(this.h) -} -func (this *QScxmlStateMachine) OnReachedStableState(slot func()) { - C.QScxmlStateMachine_connect_reachedStableState(this.h, C.intptr_t(cgo.NewHandle(slot))) -} - -//export miqt_exec_callback_QScxmlStateMachine_reachedStableState -func miqt_exec_callback_QScxmlStateMachine_reachedStableState(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 *QScxmlStateMachine) Finished() { - C.QScxmlStateMachine_finished(this.h) -} -func (this *QScxmlStateMachine) OnFinished(slot func()) { - C.QScxmlStateMachine_connect_finished(this.h, C.intptr_t(cgo.NewHandle(slot))) -} - -//export miqt_exec_callback_QScxmlStateMachine_finished -func miqt_exec_callback_QScxmlStateMachine_finished(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 *QScxmlStateMachine) DataModelChanged(model *QScxmlDataModel) { - C.QScxmlStateMachine_dataModelChanged(this.h, model.cPointer()) -} -func (this *QScxmlStateMachine) OnDataModelChanged(slot func(model *QScxmlDataModel)) { - C.QScxmlStateMachine_connect_dataModelChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) -} - -//export miqt_exec_callback_QScxmlStateMachine_dataModelChanged -func miqt_exec_callback_QScxmlStateMachine_dataModelChanged(cb C.intptr_t, model *C.QScxmlDataModel) { - gofunc, ok := cgo.Handle(cb).Value().(func(model *QScxmlDataModel)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQScxmlDataModel(model) - - gofunc(slotval1) -} - -func (this *QScxmlStateMachine) InitialValuesChanged(initialValues map[string]qt6.QVariant) { - initialValues_Keys_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(initialValues)))) - defer C.free(unsafe.Pointer(initialValues_Keys_CArray)) - initialValues_Values_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(initialValues)))) - defer C.free(unsafe.Pointer(initialValues_Values_CArray)) - initialValues_ctr := 0 - for initialValues_k, initialValues_v := range initialValues { - initialValues_k_ms := C.struct_miqt_string{} - initialValues_k_ms.data = C.CString(initialValues_k) - initialValues_k_ms.len = C.size_t(len(initialValues_k)) - defer C.free(unsafe.Pointer(initialValues_k_ms.data)) - initialValues_Keys_CArray[initialValues_ctr] = initialValues_k_ms - initialValues_Values_CArray[initialValues_ctr] = (*C.QVariant)(initialValues_v.UnsafePointer()) - initialValues_ctr++ - } - initialValues_mm := C.struct_miqt_map{ - len: C.size_t(len(initialValues)), - keys: unsafe.Pointer(initialValues_Keys_CArray), - values: unsafe.Pointer(initialValues_Values_CArray), - } - C.QScxmlStateMachine_initialValuesChanged(this.h, initialValues_mm) -} -func (this *QScxmlStateMachine) OnInitialValuesChanged(slot func(initialValues map[string]qt6.QVariant)) { - C.QScxmlStateMachine_connect_initialValuesChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) -} - -//export miqt_exec_callback_QScxmlStateMachine_initialValuesChanged -func miqt_exec_callback_QScxmlStateMachine_initialValuesChanged(cb C.intptr_t, initialValues C.struct_miqt_map) { - gofunc, ok := cgo.Handle(cb).Value().(func(initialValues map[string]qt6.QVariant)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - var initialValues_mm C.struct_miqt_map = initialValues - initialValues_ret := make(map[string]qt6.QVariant, int(initialValues_mm.len)) - initialValues_Keys := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(initialValues_mm.keys)) - initialValues_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(initialValues_mm.values)) - for i := 0; i < int(initialValues_mm.len); i++ { - var initialValues_mapkey_ms C.struct_miqt_string = initialValues_Keys[i] - initialValues_mapkey_ret := C.GoStringN(initialValues_mapkey_ms.data, C.int(int64(initialValues_mapkey_ms.len))) - C.free(unsafe.Pointer(initialValues_mapkey_ms.data)) - initialValues_entry_Key := initialValues_mapkey_ret - initialValues_mapval_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(initialValues_Values[i])) - initialValues_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - initialValues_entry_Value := *initialValues_mapval_goptr - - initialValues_ret[initialValues_entry_Key] = initialValues_entry_Value - } - slotval1 := initialValues_ret - - gofunc(slotval1) -} - -func (this *QScxmlStateMachine) InitializedChanged(initialized bool) { - C.QScxmlStateMachine_initializedChanged(this.h, (C.bool)(initialized)) -} -func (this *QScxmlStateMachine) OnInitializedChanged(slot func(initialized bool)) { - C.QScxmlStateMachine_connect_initializedChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) -} - -//export miqt_exec_callback_QScxmlStateMachine_initializedChanged -func miqt_exec_callback_QScxmlStateMachine_initializedChanged(cb C.intptr_t, initialized C.bool) { - gofunc, ok := cgo.Handle(cb).Value().(func(initialized bool)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := (bool)(initialized) - - gofunc(slotval1) -} - -func (this *QScxmlStateMachine) LoaderChanged(loader *QScxmlCompiler__Loader) { - C.QScxmlStateMachine_loaderChanged(this.h, loader.cPointer()) -} -func (this *QScxmlStateMachine) OnLoaderChanged(slot func(loader *QScxmlCompiler__Loader)) { - C.QScxmlStateMachine_connect_loaderChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) -} - -//export miqt_exec_callback_QScxmlStateMachine_loaderChanged -func miqt_exec_callback_QScxmlStateMachine_loaderChanged(cb C.intptr_t, loader *C.QScxmlCompiler__Loader) { - gofunc, ok := cgo.Handle(cb).Value().(func(loader *QScxmlCompiler__Loader)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQScxmlCompiler__Loader(loader) - - gofunc(slotval1) -} - -func (this *QScxmlStateMachine) TableDataChanged(tableData *QScxmlTableData) { - C.QScxmlStateMachine_tableDataChanged(this.h, tableData.cPointer()) -} -func (this *QScxmlStateMachine) OnTableDataChanged(slot func(tableData *QScxmlTableData)) { - C.QScxmlStateMachine_connect_tableDataChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) -} - -//export miqt_exec_callback_QScxmlStateMachine_tableDataChanged -func miqt_exec_callback_QScxmlStateMachine_tableDataChanged(cb C.intptr_t, tableData *C.QScxmlTableData) { - gofunc, ok := cgo.Handle(cb).Value().(func(tableData *QScxmlTableData)) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQScxmlTableData(tableData) - - gofunc(slotval1) -} - -func (this *QScxmlStateMachine) Start() { - C.QScxmlStateMachine_start(this.h) -} - -func (this *QScxmlStateMachine) Stop() { - C.QScxmlStateMachine_stop(this.h) -} - -func (this *QScxmlStateMachine) Init() bool { - return (bool)(C.QScxmlStateMachine_init(this.h)) -} - -func QScxmlStateMachine_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.QScxmlStateMachine_tr2(s_Cstring, c_Cstring) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func QScxmlStateMachine_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.QScxmlStateMachine_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 QScxmlStateMachine_FromData2(data *qt6.QIODevice, fileName string) *QScxmlStateMachine { - 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 newQScxmlStateMachine(C.QScxmlStateMachine_fromData2((*C.QIODevice)(data.UnsafePointer()), fileName_ms)) -} - -func (this *QScxmlStateMachine) StateNamesWithCompress(compress bool) []string { - var _ma C.struct_miqt_array = C.QScxmlStateMachine_stateNamesWithCompress(this.h, (C.bool)(compress)) - _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 *QScxmlStateMachine) ActiveStateNamesWithCompress(compress bool) []string { - var _ma C.struct_miqt_array = C.QScxmlStateMachine_activeStateNamesWithCompress(this.h, (C.bool)(compress)) - _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 *QScxmlStateMachine) ConnectToState2(scxmlStateName string, receiver *qt6.QObject, method string, typeVal qt6.ConnectionType) *qt6.QMetaObject__Connection { - scxmlStateName_ms := C.struct_miqt_string{} - scxmlStateName_ms.data = C.CString(scxmlStateName) - scxmlStateName_ms.len = C.size_t(len(scxmlStateName)) - defer C.free(unsafe.Pointer(scxmlStateName_ms.data)) - method_Cstring := C.CString(method) - defer C.free(unsafe.Pointer(method_Cstring)) - _goptr := qt6.UnsafeNewQMetaObject__Connection(unsafe.Pointer(C.QScxmlStateMachine_connectToState2(this.h, scxmlStateName_ms, (*C.QObject)(receiver.UnsafePointer()), method_Cstring, (C.int)(typeVal)))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -func (this *QScxmlStateMachine) ConnectToEvent2(scxmlEventSpec string, receiver *qt6.QObject, method string, typeVal qt6.ConnectionType) *qt6.QMetaObject__Connection { - scxmlEventSpec_ms := C.struct_miqt_string{} - scxmlEventSpec_ms.data = C.CString(scxmlEventSpec) - scxmlEventSpec_ms.len = C.size_t(len(scxmlEventSpec)) - defer C.free(unsafe.Pointer(scxmlEventSpec_ms.data)) - method_Cstring := C.CString(method) - defer C.free(unsafe.Pointer(method_Cstring)) - _goptr := qt6.UnsafeNewQMetaObject__Connection(unsafe.Pointer(C.QScxmlStateMachine_connectToEvent2(this.h, scxmlEventSpec_ms, (*C.QObject)(receiver.UnsafePointer()), method_Cstring, (C.int)(typeVal)))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -// Delete this object from C++ memory. -func (this *QScxmlStateMachine) Delete() { - C.QScxmlStateMachine_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 *QScxmlStateMachine) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlStateMachine) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} diff --git a/qt6/scxml/gen_qscxmlstatemachine.h b/qt6/scxml/gen_qscxmlstatemachine.h deleted file mode 100644 index 771c388eb..000000000 --- a/qt6/scxml/gen_qscxmlstatemachine.h +++ /dev/null @@ -1,124 +0,0 @@ -#pragma once -#ifndef MIQT_QT6_SCXML_GEN_QSCXMLSTATEMACHINE_H -#define MIQT_QT6_SCXML_GEN_QSCXMLSTATEMACHINE_H - -#include -#include -#include - -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - -#include "../../libmiqt/libmiqt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __cplusplus -class QIODevice; -class QMetaMethod; -class QMetaObject; -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QMetaObject__Connection) -typedef QMetaObject::Connection QMetaObject__Connection; -#else -class QMetaObject__Connection; -#endif -class QObject; -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlCompiler__Loader) -typedef QScxmlCompiler::Loader QScxmlCompiler__Loader; -#else -class QScxmlCompiler__Loader; -#endif -class QScxmlDataModel; -class QScxmlError; -class QScxmlEvent; -class QScxmlInvokableService; -class QScxmlStateMachine; -class QScxmlTableData; -class QVariant; -#else -typedef struct QIODevice QIODevice; -typedef struct QMetaMethod QMetaMethod; -typedef struct QMetaObject QMetaObject; -typedef struct QMetaObject__Connection QMetaObject__Connection; -typedef struct QObject QObject; -typedef struct QScxmlCompiler__Loader QScxmlCompiler__Loader; -typedef struct QScxmlDataModel QScxmlDataModel; -typedef struct QScxmlError QScxmlError; -typedef struct QScxmlEvent QScxmlEvent; -typedef struct QScxmlInvokableService QScxmlInvokableService; -typedef struct QScxmlStateMachine QScxmlStateMachine; -typedef struct QScxmlTableData QScxmlTableData; -typedef struct QVariant QVariant; -#endif - -void QScxmlStateMachine_virtbase(QScxmlStateMachine* src, QObject** outptr_QObject); -QMetaObject* QScxmlStateMachine_metaObject(const QScxmlStateMachine* self); -void* QScxmlStateMachine_metacast(QScxmlStateMachine* self, const char* param1); -struct miqt_string QScxmlStateMachine_tr(const char* s); -QScxmlStateMachine* QScxmlStateMachine_fromFile(struct miqt_string fileName); -QScxmlStateMachine* QScxmlStateMachine_fromData(QIODevice* data); -struct miqt_array /* of QScxmlError* */ QScxmlStateMachine_parseErrors(const QScxmlStateMachine* self); -struct miqt_string QScxmlStateMachine_sessionId(const QScxmlStateMachine* self); -bool QScxmlStateMachine_isInvoked(const QScxmlStateMachine* self); -bool QScxmlStateMachine_isInitialized(const QScxmlStateMachine* self); -void QScxmlStateMachine_setDataModel(QScxmlStateMachine* self, QScxmlDataModel* model); -QScxmlDataModel* QScxmlStateMachine_dataModel(const QScxmlStateMachine* self); -void QScxmlStateMachine_setLoader(QScxmlStateMachine* self, QScxmlCompiler__Loader* loader); -QScxmlCompiler__Loader* QScxmlStateMachine_loader(const QScxmlStateMachine* self); -bool QScxmlStateMachine_isRunning(const QScxmlStateMachine* self); -void QScxmlStateMachine_setRunning(QScxmlStateMachine* self, bool running); -struct miqt_map /* of struct miqt_string to QVariant* */ QScxmlStateMachine_initialValues(QScxmlStateMachine* self); -void QScxmlStateMachine_setInitialValues(QScxmlStateMachine* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialValues); -struct miqt_string QScxmlStateMachine_name(const QScxmlStateMachine* self); -struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_stateNames(const QScxmlStateMachine* self); -struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_activeStateNames(const QScxmlStateMachine* self); -bool QScxmlStateMachine_isActive(const QScxmlStateMachine* self, struct miqt_string scxmlStateName); -QMetaObject__Connection* QScxmlStateMachine_connectToState(QScxmlStateMachine* self, struct miqt_string scxmlStateName, QObject* receiver, const char* method); -QMetaObject__Connection* QScxmlStateMachine_connectToEvent(QScxmlStateMachine* self, struct miqt_string scxmlEventSpec, QObject* receiver, const char* method); -void QScxmlStateMachine_submitEvent(QScxmlStateMachine* self, QScxmlEvent* event); -void QScxmlStateMachine_submitEventWithEventName(QScxmlStateMachine* self, struct miqt_string eventName); -void QScxmlStateMachine_submitEvent2(QScxmlStateMachine* self, struct miqt_string eventName, QVariant* data); -void QScxmlStateMachine_cancelDelayedEvent(QScxmlStateMachine* self, struct miqt_string sendId); -bool QScxmlStateMachine_isDispatchableTarget(const QScxmlStateMachine* self, struct miqt_string target); -struct miqt_array /* of QScxmlInvokableService* */ QScxmlStateMachine_invokedServices(const QScxmlStateMachine* self); -QScxmlTableData* QScxmlStateMachine_tableData(const QScxmlStateMachine* self); -void QScxmlStateMachine_setTableData(QScxmlStateMachine* self, QScxmlTableData* tableData); -void QScxmlStateMachine_runningChanged(QScxmlStateMachine* self, bool running); -void QScxmlStateMachine_connect_runningChanged(QScxmlStateMachine* self, intptr_t slot); -void QScxmlStateMachine_invokedServicesChanged(QScxmlStateMachine* self, struct miqt_array /* of QScxmlInvokableService* */ invokedServices); -void QScxmlStateMachine_connect_invokedServicesChanged(QScxmlStateMachine* self, intptr_t slot); -void QScxmlStateMachine_log(QScxmlStateMachine* self, struct miqt_string label, struct miqt_string msg); -void QScxmlStateMachine_connect_log(QScxmlStateMachine* self, intptr_t slot); -void QScxmlStateMachine_reachedStableState(QScxmlStateMachine* self); -void QScxmlStateMachine_connect_reachedStableState(QScxmlStateMachine* self, intptr_t slot); -void QScxmlStateMachine_finished(QScxmlStateMachine* self); -void QScxmlStateMachine_connect_finished(QScxmlStateMachine* self, intptr_t slot); -void QScxmlStateMachine_dataModelChanged(QScxmlStateMachine* self, QScxmlDataModel* model); -void QScxmlStateMachine_connect_dataModelChanged(QScxmlStateMachine* self, intptr_t slot); -void QScxmlStateMachine_initialValuesChanged(QScxmlStateMachine* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialValues); -void QScxmlStateMachine_connect_initialValuesChanged(QScxmlStateMachine* self, intptr_t slot); -void QScxmlStateMachine_initializedChanged(QScxmlStateMachine* self, bool initialized); -void QScxmlStateMachine_connect_initializedChanged(QScxmlStateMachine* self, intptr_t slot); -void QScxmlStateMachine_loaderChanged(QScxmlStateMachine* self, QScxmlCompiler__Loader* loader); -void QScxmlStateMachine_connect_loaderChanged(QScxmlStateMachine* self, intptr_t slot); -void QScxmlStateMachine_tableDataChanged(QScxmlStateMachine* self, QScxmlTableData* tableData); -void QScxmlStateMachine_connect_tableDataChanged(QScxmlStateMachine* self, intptr_t slot); -void QScxmlStateMachine_start(QScxmlStateMachine* self); -void QScxmlStateMachine_stop(QScxmlStateMachine* self); -bool QScxmlStateMachine_init(QScxmlStateMachine* self); -struct miqt_string QScxmlStateMachine_tr2(const char* s, const char* c); -struct miqt_string QScxmlStateMachine_tr3(const char* s, const char* c, int n); -QScxmlStateMachine* QScxmlStateMachine_fromData2(QIODevice* data, struct miqt_string fileName); -struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_stateNamesWithCompress(const QScxmlStateMachine* self, bool compress); -struct miqt_array /* of struct miqt_string */ QScxmlStateMachine_activeStateNamesWithCompress(const QScxmlStateMachine* self, bool compress); -QMetaObject__Connection* QScxmlStateMachine_connectToState2(QScxmlStateMachine* self, struct miqt_string scxmlStateName, QObject* receiver, const char* method, int type); -QMetaObject__Connection* QScxmlStateMachine_connectToEvent2(QScxmlStateMachine* self, struct miqt_string scxmlEventSpec, QObject* receiver, const char* method, int type); - -void QScxmlStateMachine_delete(QScxmlStateMachine* self); - -#ifdef __cplusplus -} /* extern C */ -#endif - -#endif diff --git a/qt6/scxml/gen_qscxmltabledata.cpp b/qt6/scxml/gen_qscxmltabledata.cpp deleted file mode 100644 index 7a3167eb1..000000000 --- a/qt6/scxml/gen_qscxmltabledata.cpp +++ /dev/null @@ -1,85 +0,0 @@ -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__AssignmentInfo -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__EvaluatorInfo -#define WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ForeachInfo -#include -#include -#include -#include -#include -#include -#include "gen_qscxmltabledata.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __cplusplus -} /* extern C */ -#endif - -struct miqt_string QScxmlTableData_string(const QScxmlTableData* self, int id) { - QString _ret = self->string(static_cast(id)); - // 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* QScxmlTableData_instructions(const QScxmlTableData* self) { - QScxmlExecutableContent::InstructionId* _ret = self->instructions(); - return static_cast(_ret); -} - -QScxmlExecutableContent__EvaluatorInfo* QScxmlTableData_evaluatorInfo(const QScxmlTableData* self, int evaluatorId) { - return new QScxmlExecutableContent::EvaluatorInfo(self->evaluatorInfo(static_cast(evaluatorId))); -} - -QScxmlExecutableContent__AssignmentInfo* QScxmlTableData_assignmentInfo(const QScxmlTableData* self, int assignmentId) { - return new QScxmlExecutableContent::AssignmentInfo(self->assignmentInfo(static_cast(assignmentId))); -} - -QScxmlExecutableContent__ForeachInfo* QScxmlTableData_foreachInfo(const QScxmlTableData* self, int foreachId) { - return new QScxmlExecutableContent::ForeachInfo(self->foreachInfo(static_cast(foreachId))); -} - -int* QScxmlTableData_dataNames(const QScxmlTableData* self, int* count) { - QScxmlExecutableContent::StringId* _ret = self->dataNames(static_cast(count)); - return static_cast(_ret); -} - -int QScxmlTableData_initialSetup(const QScxmlTableData* self) { - QScxmlExecutableContent::ContainerId _ret = self->initialSetup(); - return static_cast(_ret); -} - -struct miqt_string QScxmlTableData_name(const QScxmlTableData* self) { - QString _ret = self->name(); - // 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; -} - -const int* QScxmlTableData_stateMachineTable(const QScxmlTableData* self) { - const qint32* _ret = self->stateMachineTable(); - return static_cast(_ret); -} - -QScxmlInvokableServiceFactory* QScxmlTableData_serviceFactory(const QScxmlTableData* self, int id) { - return self->serviceFactory(static_cast(id)); -} - -void QScxmlTableData_operatorAssign(QScxmlTableData* self, QScxmlTableData* param1) { - self->operator=(*param1); -} - -void QScxmlTableData_delete(QScxmlTableData* self) { - delete self; -} - diff --git a/qt6/scxml/gen_qscxmltabledata.go b/qt6/scxml/gen_qscxmltabledata.go deleted file mode 100644 index 863bf70be..000000000 --- a/qt6/scxml/gen_qscxmltabledata.go +++ /dev/null @@ -1,116 +0,0 @@ -package scxml - -/* - -#include "gen_qscxmltabledata.h" -#include - -*/ -import "C" - -import ( - "runtime" - "unsafe" -) - -type QScxmlTableData struct { - h *C.QScxmlTableData -} - -func (this *QScxmlTableData) cPointer() *C.QScxmlTableData { - if this == nil { - return nil - } - return this.h -} - -func (this *QScxmlTableData) UnsafePointer() unsafe.Pointer { - if this == nil { - return nil - } - return unsafe.Pointer(this.h) -} - -// newQScxmlTableData constructs the type using only CGO pointers. -func newQScxmlTableData(h *C.QScxmlTableData) *QScxmlTableData { - if h == nil { - return nil - } - - return &QScxmlTableData{h: h} -} - -// UnsafeNewQScxmlTableData constructs the type using only unsafe pointers. -func UnsafeNewQScxmlTableData(h unsafe.Pointer) *QScxmlTableData { - return newQScxmlTableData((*C.QScxmlTableData)(h)) -} - -func (this *QScxmlTableData) String(id int) string { - var _ms C.struct_miqt_string = C.QScxmlTableData_string(this.h, (C.int)(id)) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlTableData) Instructions() *int { - return (*int)(unsafe.Pointer(C.QScxmlTableData_instructions(this.h))) -} - -func (this *QScxmlTableData) EvaluatorInfo(evaluatorId int) *QScxmlExecutableContent__EvaluatorInfo { - _goptr := newQScxmlExecutableContent__EvaluatorInfo(C.QScxmlTableData_evaluatorInfo(this.h, (C.int)(evaluatorId))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -func (this *QScxmlTableData) AssignmentInfo(assignmentId int) *QScxmlExecutableContent__AssignmentInfo { - _goptr := newQScxmlExecutableContent__AssignmentInfo(C.QScxmlTableData_assignmentInfo(this.h, (C.int)(assignmentId))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -func (this *QScxmlTableData) ForeachInfo(foreachId int) *QScxmlExecutableContent__ForeachInfo { - _goptr := newQScxmlExecutableContent__ForeachInfo(C.QScxmlTableData_foreachInfo(this.h, (C.int)(foreachId))) - _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer - return _goptr -} - -func (this *QScxmlTableData) DataNames(count *int) *int { - return (*int)(unsafe.Pointer(C.QScxmlTableData_dataNames(this.h, (*C.int)(unsafe.Pointer(count))))) -} - -func (this *QScxmlTableData) InitialSetup() int { - return (int)(C.QScxmlTableData_initialSetup(this.h)) -} - -func (this *QScxmlTableData) Name() string { - var _ms C.struct_miqt_string = C.QScxmlTableData_name(this.h) - _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) - C.free(unsafe.Pointer(_ms.data)) - return _ret -} - -func (this *QScxmlTableData) StateMachineTable() *int { - return (*int)(unsafe.Pointer(C.QScxmlTableData_stateMachineTable(this.h))) -} - -func (this *QScxmlTableData) ServiceFactory(id int) *QScxmlInvokableServiceFactory { - return newQScxmlInvokableServiceFactory(C.QScxmlTableData_serviceFactory(this.h, (C.int)(id))) -} - -func (this *QScxmlTableData) OperatorAssign(param1 *QScxmlTableData) { - C.QScxmlTableData_operatorAssign(this.h, param1.cPointer()) -} - -// Delete this object from C++ memory. -func (this *QScxmlTableData) Delete() { - C.QScxmlTableData_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 *QScxmlTableData) GoGC() { - runtime.SetFinalizer(this, func(this *QScxmlTableData) { - this.Delete() - runtime.KeepAlive(this.h) - }) -} diff --git a/qt6/scxml/gen_qscxmltabledata.h b/qt6/scxml/gen_qscxmltabledata.h deleted file mode 100644 index 1fd346803..000000000 --- a/qt6/scxml/gen_qscxmltabledata.h +++ /dev/null @@ -1,61 +0,0 @@ -#pragma once -#ifndef MIQT_QT6_SCXML_GEN_QSCXMLTABLEDATA_H -#define MIQT_QT6_SCXML_GEN_QSCXMLTABLEDATA_H - -#include -#include -#include - -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - -#include "../../libmiqt/libmiqt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __cplusplus -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__AssignmentInfo) -typedef QScxmlExecutableContent::AssignmentInfo QScxmlExecutableContent__AssignmentInfo; -#else -class QScxmlExecutableContent__AssignmentInfo; -#endif -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__EvaluatorInfo) -typedef QScxmlExecutableContent::EvaluatorInfo QScxmlExecutableContent__EvaluatorInfo; -#else -class QScxmlExecutableContent__EvaluatorInfo; -#endif -#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QScxmlExecutableContent__ForeachInfo) -typedef QScxmlExecutableContent::ForeachInfo QScxmlExecutableContent__ForeachInfo; -#else -class QScxmlExecutableContent__ForeachInfo; -#endif -class QScxmlInvokableServiceFactory; -class QScxmlTableData; -#else -typedef struct QScxmlExecutableContent__AssignmentInfo QScxmlExecutableContent__AssignmentInfo; -typedef struct QScxmlExecutableContent__EvaluatorInfo QScxmlExecutableContent__EvaluatorInfo; -typedef struct QScxmlExecutableContent__ForeachInfo QScxmlExecutableContent__ForeachInfo; -typedef struct QScxmlInvokableServiceFactory QScxmlInvokableServiceFactory; -typedef struct QScxmlTableData QScxmlTableData; -#endif - -struct miqt_string QScxmlTableData_string(const QScxmlTableData* self, int id); -int* QScxmlTableData_instructions(const QScxmlTableData* self); -QScxmlExecutableContent__EvaluatorInfo* QScxmlTableData_evaluatorInfo(const QScxmlTableData* self, int evaluatorId); -QScxmlExecutableContent__AssignmentInfo* QScxmlTableData_assignmentInfo(const QScxmlTableData* self, int assignmentId); -QScxmlExecutableContent__ForeachInfo* QScxmlTableData_foreachInfo(const QScxmlTableData* self, int foreachId); -int* QScxmlTableData_dataNames(const QScxmlTableData* self, int* count); -int QScxmlTableData_initialSetup(const QScxmlTableData* self); -struct miqt_string QScxmlTableData_name(const QScxmlTableData* self); -const int* QScxmlTableData_stateMachineTable(const QScxmlTableData* self); -QScxmlInvokableServiceFactory* QScxmlTableData_serviceFactory(const QScxmlTableData* self, int id); -void QScxmlTableData_operatorAssign(QScxmlTableData* self, QScxmlTableData* param1); - -void QScxmlTableData_delete(QScxmlTableData* self); - -#ifdef __cplusplus -} /* extern C */ -#endif - -#endif