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 diff --git a/cmd/genbindings/config-libraries.go b/cmd/genbindings/config-libraries.go index 8c6054de5..40a70d85a 100644 --- a/cmd/genbindings/config-libraries.go +++ b/cmd/genbindings/config-libraries.go @@ -603,6 +603,21 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) { ClangMatchSameHeaderDefinitionOnly, ) + // Qt 6 State Machine + // 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, + "--std=c++17 "+pkgConfigCflags("Qt6StateMachineQml"), + 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 \ diff --git a/examples/libraries/qt6-statemachine/main.go b/examples/libraries/qt6-statemachine/main.go new file mode 100644 index 000000000..b62d08d1c --- /dev/null +++ b/examples/libraries/qt6-statemachine/main.go @@ -0,0 +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) + + 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 000000000..4ac366e10 Binary files /dev/null and b/examples/libraries/qt6-statemachine/screenshot.png differ 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" 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