From 23e65c9e005633cb797a90c0fa491fddf265f9c7 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Mon, 2 Feb 2026 17:26:34 -0500 Subject: [PATCH 1/6] config-libraries.go: Add WebSockets --- cmd/genbindings/config-libraries.go | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/cmd/genbindings/config-libraries.go b/cmd/genbindings/config-libraries.go index 8c6054de5..e4b0f141a 100644 --- a/cmd/genbindings/config-libraries.go +++ b/cmd/genbindings/config-libraries.go @@ -200,6 +200,20 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) { ClangMatchSameHeaderDefinitionOnly, ) + // Qt 5 QWebSockets + // Depends on QtCore + generate( + "qt/websockets", + []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtWebSockets", + }, + AllowAllHeaders, + clangBin, + pkgConfigCflags("Qt5WebSockets"), + outDir, + ClangMatchSameHeaderDefinitionOnly, + ) + // Qt 5 PDF // Depends on QtCore/Gui/Widgets generate( @@ -519,7 +533,22 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) { ClangMatchSameHeaderDefinitionOnly, ) + // Qt 6 QWebSockets + // Depends on QtCore + generate( + "qt6/websockets", + []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtWebSockets", + }, + AllowAllHeaders, + clangBin, + "--std=c++17 "+pkgConfigCflags("Qt6WebSockets"), + outDir, + ClangMatchSameHeaderDefinitionOnly, + ) + // Qt 6 PDF + // Depends on QtCore/Gui/Widgets generate( "qt6/pdf", []string{ From 3bd74aaf3e93fcaef5831b326c817bac8c6d329b Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Mon, 2 Feb 2026 17:27:54 -0500 Subject: [PATCH 2/6] qt: Rebuild (Add Qt WebSockets) --- qt/websockets/cflags.go | 7 + qt/websockets/gen_qmaskgenerator.cpp | 376 ++++++ qt/websockets/gen_qmaskgenerator.go | 370 ++++++ qt/websockets/gen_qmaskgenerator.h | 69 + qt/websockets/gen_qwebsocket.cpp | 918 ++++++++++++++ qt/websockets/gen_qwebsocket.go | 1028 +++++++++++++++ qt/websockets/gen_qwebsocket.h | 173 +++ .../gen_qwebsocketcorsauthenticator.cpp | 55 + .../gen_qwebsocketcorsauthenticator.go | 99 ++ .../gen_qwebsocketcorsauthenticator.h | 37 + qt/websockets/gen_qwebsocketprotocol.cpp | 11 + qt/websockets/gen_qwebsocketprotocol.go | 41 + qt/websockets/gen_qwebsocketprotocol.h | 25 + qt/websockets/gen_qwebsocketserver.cpp | 705 +++++++++++ qt/websockets/gen_qwebsocketserver.go | 753 +++++++++++ qt/websockets/gen_qwebsocketserver.h | 140 ++ qt6/websockets/cflags.go | 7 + qt6/websockets/gen_qmaskgenerator.cpp | 376 ++++++ qt6/websockets/gen_qmaskgenerator.go | 370 ++++++ qt6/websockets/gen_qmaskgenerator.h | 69 + qt6/websockets/gen_qwebsocket.cpp | 989 +++++++++++++++ qt6/websockets/gen_qwebsocket.go | 1124 +++++++++++++++++ qt6/websockets/gen_qwebsocket.h | 185 +++ .../gen_qwebsocketcorsauthenticator.cpp | 55 + .../gen_qwebsocketcorsauthenticator.go | 99 ++ .../gen_qwebsocketcorsauthenticator.h | 37 + .../gen_qwebsockethandshakeoptions.cpp | 67 + .../gen_qwebsockethandshakeoptions.go | 107 ++ .../gen_qwebsockethandshakeoptions.h | 36 + qt6/websockets/gen_qwebsocketprotocol.cpp | 11 + qt6/websockets/gen_qwebsocketprotocol.go | 41 + qt6/websockets/gen_qwebsocketprotocol.h | 25 + qt6/websockets/gen_qwebsocketserver.cpp | 766 +++++++++++ qt6/websockets/gen_qwebsocketserver.go | 831 ++++++++++++ qt6/websockets/gen_qwebsocketserver.h | 145 +++ 35 files changed, 10147 insertions(+) create mode 100644 qt/websockets/cflags.go create mode 100644 qt/websockets/gen_qmaskgenerator.cpp create mode 100644 qt/websockets/gen_qmaskgenerator.go create mode 100644 qt/websockets/gen_qmaskgenerator.h create mode 100644 qt/websockets/gen_qwebsocket.cpp create mode 100644 qt/websockets/gen_qwebsocket.go create mode 100644 qt/websockets/gen_qwebsocket.h create mode 100644 qt/websockets/gen_qwebsocketcorsauthenticator.cpp create mode 100644 qt/websockets/gen_qwebsocketcorsauthenticator.go create mode 100644 qt/websockets/gen_qwebsocketcorsauthenticator.h create mode 100644 qt/websockets/gen_qwebsocketprotocol.cpp create mode 100644 qt/websockets/gen_qwebsocketprotocol.go create mode 100644 qt/websockets/gen_qwebsocketprotocol.h create mode 100644 qt/websockets/gen_qwebsocketserver.cpp create mode 100644 qt/websockets/gen_qwebsocketserver.go create mode 100644 qt/websockets/gen_qwebsocketserver.h create mode 100644 qt6/websockets/cflags.go create mode 100644 qt6/websockets/gen_qmaskgenerator.cpp create mode 100644 qt6/websockets/gen_qmaskgenerator.go create mode 100644 qt6/websockets/gen_qmaskgenerator.h create mode 100644 qt6/websockets/gen_qwebsocket.cpp create mode 100644 qt6/websockets/gen_qwebsocket.go create mode 100644 qt6/websockets/gen_qwebsocket.h create mode 100644 qt6/websockets/gen_qwebsocketcorsauthenticator.cpp create mode 100644 qt6/websockets/gen_qwebsocketcorsauthenticator.go create mode 100644 qt6/websockets/gen_qwebsocketcorsauthenticator.h create mode 100644 qt6/websockets/gen_qwebsockethandshakeoptions.cpp create mode 100644 qt6/websockets/gen_qwebsockethandshakeoptions.go create mode 100644 qt6/websockets/gen_qwebsockethandshakeoptions.h create mode 100644 qt6/websockets/gen_qwebsocketprotocol.cpp create mode 100644 qt6/websockets/gen_qwebsocketprotocol.go create mode 100644 qt6/websockets/gen_qwebsocketprotocol.h create mode 100644 qt6/websockets/gen_qwebsocketserver.cpp create mode 100644 qt6/websockets/gen_qwebsocketserver.go create mode 100644 qt6/websockets/gen_qwebsocketserver.h diff --git a/qt/websockets/cflags.go b/qt/websockets/cflags.go new file mode 100644 index 000000000..d096dd9b0 --- /dev/null +++ b/qt/websockets/cflags.go @@ -0,0 +1,7 @@ +package websockets + +/* +#cgo pkg-config: Qt5WebSockets +*/ +import "C" + diff --git a/qt/websockets/gen_qmaskgenerator.cpp b/qt/websockets/gen_qmaskgenerator.cpp new file mode 100644 index 000000000..2928fe366 --- /dev/null +++ b/qt/websockets/gen_qmaskgenerator.cpp @@ -0,0 +1,376 @@ +#include +#include +#include +#include +#include +#include +#include +#include "gen_qmaskgenerator.h" + +#ifdef __cplusplus +extern "C" { +#endif + +bool miqt_exec_callback_QMaskGenerator_seed(QMaskGenerator*, intptr_t); +unsigned int miqt_exec_callback_QMaskGenerator_nextMask(QMaskGenerator*, intptr_t); +bool miqt_exec_callback_QMaskGenerator_event(QMaskGenerator*, intptr_t, QEvent*); +bool miqt_exec_callback_QMaskGenerator_eventFilter(QMaskGenerator*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QMaskGenerator_timerEvent(QMaskGenerator*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QMaskGenerator_childEvent(QMaskGenerator*, intptr_t, QChildEvent*); +void miqt_exec_callback_QMaskGenerator_customEvent(QMaskGenerator*, intptr_t, QEvent*); +void miqt_exec_callback_QMaskGenerator_connectNotify(QMaskGenerator*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QMaskGenerator_disconnectNotify(QMaskGenerator*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQMaskGenerator final : public QMaskGenerator { +public: + + MiqtVirtualQMaskGenerator(): QMaskGenerator() {} + MiqtVirtualQMaskGenerator(QObject* parent): QMaskGenerator(parent) {} + + virtual ~MiqtVirtualQMaskGenerator() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__seed = 0; + + // Subclass to allow providing a Go implementation + virtual bool seed() override { + if (handle__seed == 0) { + return false; // Pure virtual, there is no base we can call + } + + bool callback_return_value = miqt_exec_callback_QMaskGenerator_seed(this, handle__seed); + return callback_return_value; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__nextMask = 0; + + // Subclass to allow providing a Go implementation + virtual quint32 nextMask() override { + if (handle__nextMask == 0) { + return 0; // Pure virtual, there is no base we can call + } + + unsigned int callback_return_value = miqt_exec_callback_QMaskGenerator_nextMask(this, handle__nextMask); + return static_cast(callback_return_value); + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QMaskGenerator::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QMaskGenerator_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QMaskGenerator_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QMaskGenerator::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QMaskGenerator_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QMaskGenerator_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) { + QMaskGenerator::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QMaskGenerator_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QMaskGenerator_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) { + QMaskGenerator::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QMaskGenerator_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QMaskGenerator_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) { + QMaskGenerator::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QMaskGenerator_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QMaskGenerator_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) { + QMaskGenerator::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QMaskGenerator_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QMaskGenerator_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) { + QMaskGenerator::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QMaskGenerator_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QMaskGenerator_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QMaskGenerator_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QMaskGenerator_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QMaskGenerator_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QMaskGenerator_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QMaskGenerator* QMaskGenerator_new() { + return new (std::nothrow) MiqtVirtualQMaskGenerator(); +} + +QMaskGenerator* QMaskGenerator_new2(QObject* parent) { + return new (std::nothrow) MiqtVirtualQMaskGenerator(parent); +} + +void QMaskGenerator_virtbase(QMaskGenerator* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +bool QMaskGenerator_seed(QMaskGenerator* self) { + return self->seed(); +} + +unsigned int QMaskGenerator_nextMask(QMaskGenerator* self) { + quint32 _ret = self->nextMask(); + return static_cast(_ret); +} + +bool QMaskGenerator_override_virtual_seed(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__seed = slot; + return true; +} + +bool QMaskGenerator_override_virtual_nextMask(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__nextMask = slot; + return true; +} + +bool QMaskGenerator_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QMaskGenerator_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QMaskGenerator::event(event); +} + +bool QMaskGenerator_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QMaskGenerator_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QMaskGenerator::eventFilter(watched, event); +} + +bool QMaskGenerator_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QMaskGenerator_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QMaskGenerator::timerEvent(event); +} + +bool QMaskGenerator_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QMaskGenerator_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QMaskGenerator::childEvent(event); +} + +bool QMaskGenerator_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QMaskGenerator_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QMaskGenerator::customEvent(event); +} + +bool QMaskGenerator_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QMaskGenerator_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QMaskGenerator::connectNotify(*signal); +} + +bool QMaskGenerator_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QMaskGenerator_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QMaskGenerator::disconnectNotify(*signal); +} + +QObject* QMaskGenerator_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QMaskGenerator_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QMaskGenerator_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QMaskGenerator_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QMaskGenerator_delete(QMaskGenerator* self) { + delete self; +} + diff --git a/qt/websockets/gen_qmaskgenerator.go b/qt/websockets/gen_qmaskgenerator.go new file mode 100644 index 000000000..70961f1d6 --- /dev/null +++ b/qt/websockets/gen_qmaskgenerator.go @@ -0,0 +1,370 @@ +package websockets + +/* + +#include "gen_qmaskgenerator.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QMaskGenerator struct { + h *C.QMaskGenerator + *qt.QObject +} + +func (this *QMaskGenerator) cPointer() *C.QMaskGenerator { + if this == nil { + return nil + } + return this.h +} + +func (this *QMaskGenerator) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQMaskGenerator constructs the type using only CGO pointers. +func newQMaskGenerator(h *C.QMaskGenerator) *QMaskGenerator { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QMaskGenerator_virtbase(h, &outptr_QObject) + + return &QMaskGenerator{h: h, + QObject: qt.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQMaskGenerator constructs the type using only unsafe pointers. +func UnsafeNewQMaskGenerator(h unsafe.Pointer) *QMaskGenerator { + return newQMaskGenerator((*C.QMaskGenerator)(h)) +} + +// NewQMaskGenerator constructs a new QMaskGenerator object. +func NewQMaskGenerator() *QMaskGenerator { + + return newQMaskGenerator(C.QMaskGenerator_new()) +} + +// NewQMaskGenerator2 constructs a new QMaskGenerator object. +func NewQMaskGenerator2(parent *qt.QObject) *QMaskGenerator { + + return newQMaskGenerator(C.QMaskGenerator_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QMaskGenerator) Seed() bool { + return (bool)(C.QMaskGenerator_seed(this.h)) +} + +func (this *QMaskGenerator) NextMask() uint { + return (uint)(C.QMaskGenerator_nextMask(this.h)) +} + +// Sender can only be called from a QMaskGenerator that was directly constructed. +func (this *QMaskGenerator) Sender() *qt.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt.UnsafeNewQObject(unsafe.Pointer(C.QMaskGenerator_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 QMaskGenerator that was directly constructed. +func (this *QMaskGenerator) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QMaskGenerator_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 QMaskGenerator that was directly constructed. +func (this *QMaskGenerator) 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.QMaskGenerator_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 QMaskGenerator that was directly constructed. +func (this *QMaskGenerator) IsSignalConnected(signal *qt.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QMaskGenerator_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 *QMaskGenerator) OnSeed(slot func() bool) { + ok := C.QMaskGenerator_override_virtual_seed(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QMaskGenerator_seed +func miqt_exec_callback_QMaskGenerator_seed(self *C.QMaskGenerator, cb C.intptr_t) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func() bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc() + + return (C.bool)(virtualReturn) + +} +func (this *QMaskGenerator) OnNextMask(slot func() uint) { + ok := C.QMaskGenerator_override_virtual_nextMask(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QMaskGenerator_nextMask +func miqt_exec_callback_QMaskGenerator_nextMask(self *C.QMaskGenerator, cb C.intptr_t) C.uint { + gofunc, ok := cgo.Handle(cb).Value().(func() uint) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc() + + return (C.uint)(virtualReturn) + +} + +func (this *QMaskGenerator) callVirtualBase_Event(event *qt.QEvent) bool { + + return (bool)(C.QMaskGenerator_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QMaskGenerator) OnEvent(slot func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) { + ok := C.QMaskGenerator_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_QMaskGenerator_event +func miqt_exec_callback_QMaskGenerator_event(self *C.QMaskGenerator, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QMaskGenerator{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QMaskGenerator) callVirtualBase_EventFilter(watched *qt.QObject, event *qt.QEvent) bool { + + return (bool)(C.QMaskGenerator_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QMaskGenerator) OnEventFilter(slot func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) { + ok := C.QMaskGenerator_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_QMaskGenerator_eventFilter +func miqt_exec_callback_QMaskGenerator_eventFilter(self *C.QMaskGenerator, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QMaskGenerator{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QMaskGenerator) callVirtualBase_TimerEvent(event *qt.QTimerEvent) { + + C.QMaskGenerator_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QMaskGenerator) OnTimerEvent(slot func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) { + ok := C.QMaskGenerator_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_QMaskGenerator_timerEvent +func miqt_exec_callback_QMaskGenerator_timerEvent(self *C.QMaskGenerator, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QMaskGenerator{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QMaskGenerator) callVirtualBase_ChildEvent(event *qt.QChildEvent) { + + C.QMaskGenerator_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QMaskGenerator) OnChildEvent(slot func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) { + ok := C.QMaskGenerator_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_QMaskGenerator_childEvent +func miqt_exec_callback_QMaskGenerator_childEvent(self *C.QMaskGenerator, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QMaskGenerator{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QMaskGenerator) callVirtualBase_CustomEvent(event *qt.QEvent) { + + C.QMaskGenerator_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QMaskGenerator) OnCustomEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) { + ok := C.QMaskGenerator_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_QMaskGenerator_customEvent +func miqt_exec_callback_QMaskGenerator_customEvent(self *C.QMaskGenerator, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QMaskGenerator{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QMaskGenerator) callVirtualBase_ConnectNotify(signal *qt.QMetaMethod) { + + C.QMaskGenerator_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QMaskGenerator) OnConnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QMaskGenerator_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_QMaskGenerator_connectNotify +func miqt_exec_callback_QMaskGenerator_connectNotify(self *C.QMaskGenerator, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QMaskGenerator{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QMaskGenerator) callVirtualBase_DisconnectNotify(signal *qt.QMetaMethod) { + + C.QMaskGenerator_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QMaskGenerator) OnDisconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QMaskGenerator_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_QMaskGenerator_disconnectNotify +func miqt_exec_callback_QMaskGenerator_disconnectNotify(self *C.QMaskGenerator, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QMaskGenerator{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QMaskGenerator) Delete() { + C.QMaskGenerator_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 *QMaskGenerator) GoGC() { + runtime.SetFinalizer(this, func(this *QMaskGenerator) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/websockets/gen_qmaskgenerator.h b/qt/websockets/gen_qmaskgenerator.h new file mode 100644 index 000000000..a4441738d --- /dev/null +++ b/qt/websockets/gen_qmaskgenerator.h @@ -0,0 +1,69 @@ +#pragma once +#ifndef MIQT_QT_WEBSOCKETS_GEN_QMASKGENERATOR_H +#define MIQT_QT_WEBSOCKETS_GEN_QMASKGENERATOR_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QChildEvent; +class QEvent; +class QMaskGenerator; +class QMetaMethod; +class QObject; +class QTimerEvent; +#else +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QMaskGenerator QMaskGenerator; +typedef struct QMetaMethod QMetaMethod; +typedef struct QObject QObject; +typedef struct QTimerEvent QTimerEvent; +#endif + +QMaskGenerator* QMaskGenerator_new(); +QMaskGenerator* QMaskGenerator_new2(QObject* parent); +void QMaskGenerator_virtbase(QMaskGenerator* src, QObject** outptr_QObject); +bool QMaskGenerator_seed(QMaskGenerator* self); +unsigned int QMaskGenerator_nextMask(QMaskGenerator* self); + +bool QMaskGenerator_override_virtual_seed(void* self, intptr_t slot); +bool QMaskGenerator_virtualbase_seed(void* self); +bool QMaskGenerator_override_virtual_nextMask(void* self, intptr_t slot); +unsigned int QMaskGenerator_virtualbase_nextMask(void* self); +bool QMaskGenerator_override_virtual_event(void* self, intptr_t slot); +bool QMaskGenerator_virtualbase_event(void* self, QEvent* event); +bool QMaskGenerator_override_virtual_eventFilter(void* self, intptr_t slot); +bool QMaskGenerator_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QMaskGenerator_override_virtual_timerEvent(void* self, intptr_t slot); +void QMaskGenerator_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QMaskGenerator_override_virtual_childEvent(void* self, intptr_t slot); +void QMaskGenerator_virtualbase_childEvent(void* self, QChildEvent* event); +bool QMaskGenerator_override_virtual_customEvent(void* self, intptr_t slot); +void QMaskGenerator_virtualbase_customEvent(void* self, QEvent* event); +bool QMaskGenerator_override_virtual_connectNotify(void* self, intptr_t slot); +void QMaskGenerator_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QMaskGenerator_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QMaskGenerator_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QMaskGenerator_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QMaskGenerator_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QMaskGenerator_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QMaskGenerator_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QMaskGenerator_delete(QMaskGenerator* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/websockets/gen_qwebsocket.cpp b/qt/websockets/gen_qwebsocket.cpp new file mode 100644 index 000000000..bf4a9c149 --- /dev/null +++ b/qt/websockets/gen_qwebsocket.cpp @@ -0,0 +1,918 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qwebsocket.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QWebSocket_aboutToClose(intptr_t); +void miqt_exec_callback_QWebSocket_connected(intptr_t); +void miqt_exec_callback_QWebSocket_disconnected(intptr_t); +void miqt_exec_callback_QWebSocket_stateChanged(intptr_t, int); +void miqt_exec_callback_QWebSocket_proxyAuthenticationRequired(intptr_t, QNetworkProxy*, QAuthenticator*); +void miqt_exec_callback_QWebSocket_readChannelFinished(intptr_t); +void miqt_exec_callback_QWebSocket_textFrameReceived(intptr_t, struct miqt_string, bool); +void miqt_exec_callback_QWebSocket_binaryFrameReceived(intptr_t, struct miqt_string, bool); +void miqt_exec_callback_QWebSocket_textMessageReceived(intptr_t, struct miqt_string); +void miqt_exec_callback_QWebSocket_binaryMessageReceived(intptr_t, struct miqt_string); +void miqt_exec_callback_QWebSocket_errorWithError(intptr_t, int); +void miqt_exec_callback_QWebSocket_pong(intptr_t, unsigned long long, struct miqt_string); +void miqt_exec_callback_QWebSocket_bytesWritten(intptr_t, long long); +void miqt_exec_callback_QWebSocket_sslErrors(intptr_t, struct miqt_array /* of QSslError* */ ); +void miqt_exec_callback_QWebSocket_preSharedKeyAuthenticationRequired(intptr_t, QSslPreSharedKeyAuthenticator*); +bool miqt_exec_callback_QWebSocket_event(QWebSocket*, intptr_t, QEvent*); +bool miqt_exec_callback_QWebSocket_eventFilter(QWebSocket*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QWebSocket_timerEvent(QWebSocket*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QWebSocket_childEvent(QWebSocket*, intptr_t, QChildEvent*); +void miqt_exec_callback_QWebSocket_customEvent(QWebSocket*, intptr_t, QEvent*); +void miqt_exec_callback_QWebSocket_connectNotify(QWebSocket*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QWebSocket_disconnectNotify(QWebSocket*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQWebSocket final : public QWebSocket { +public: + + MiqtVirtualQWebSocket(): QWebSocket() {} + MiqtVirtualQWebSocket(const QString& origin): QWebSocket(origin) {} + MiqtVirtualQWebSocket(const QString& origin, QWebSocketProtocol::Version version): QWebSocket(origin, version) {} + MiqtVirtualQWebSocket(const QString& origin, QWebSocketProtocol::Version version, QObject* parent): QWebSocket(origin, version, parent) {} + + virtual ~MiqtVirtualQWebSocket() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QWebSocket::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QWebSocket_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QWebSocket_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QWebSocket::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QWebSocket_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QWebSocket_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) { + QWebSocket::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QWebSocket_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QWebSocket_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) { + QWebSocket::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QWebSocket_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QWebSocket_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) { + QWebSocket::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QWebSocket_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QWebSocket_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) { + QWebSocket::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QWebSocket_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QWebSocket_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) { + QWebSocket::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QWebSocket_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QWebSocket_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QWebSocket_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QWebSocket_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QWebSocket_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QWebSocket_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QWebSocket* QWebSocket_new() { + return new (std::nothrow) MiqtVirtualQWebSocket(); +} + +QWebSocket* QWebSocket_new2(struct miqt_string origin) { + QString origin_QString = QString::fromUtf8(origin.data, origin.len); + return new (std::nothrow) MiqtVirtualQWebSocket(origin_QString); +} + +QWebSocket* QWebSocket_new3(struct miqt_string origin, int version) { + QString origin_QString = QString::fromUtf8(origin.data, origin.len); + return new (std::nothrow) MiqtVirtualQWebSocket(origin_QString, static_cast(version)); +} + +QWebSocket* QWebSocket_new4(struct miqt_string origin, int version, QObject* parent) { + QString origin_QString = QString::fromUtf8(origin.data, origin.len); + return new (std::nothrow) MiqtVirtualQWebSocket(origin_QString, static_cast(version), parent); +} + +void QWebSocket_virtbase(QWebSocket* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QWebSocket_metaObject(const QWebSocket* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QWebSocket_metacast(QWebSocket* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QWebSocket_tr(const char* s) { + QString _ret = QWebSocket::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 QWebSocket_trUtf8(const char* s) { + QString _ret = QWebSocket::trUtf8(s); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +void QWebSocket_abort(QWebSocket* self) { + self->abort(); +} + +int QWebSocket_error(const QWebSocket* self) { + QAbstractSocket::SocketError _ret = self->error(); + return static_cast(_ret); +} + +struct miqt_string QWebSocket_errorString(const QWebSocket* 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; +} + +bool QWebSocket_flush(QWebSocket* self) { + return self->flush(); +} + +bool QWebSocket_isValid(const QWebSocket* self) { + return self->isValid(); +} + +QHostAddress* QWebSocket_localAddress(const QWebSocket* self) { + return new QHostAddress(self->localAddress()); +} + +unsigned short QWebSocket_localPort(const QWebSocket* self) { + quint16 _ret = self->localPort(); + return static_cast(_ret); +} + +int QWebSocket_pauseMode(const QWebSocket* self) { + QAbstractSocket::PauseModes _ret = self->pauseMode(); + return static_cast(_ret); +} + +QHostAddress* QWebSocket_peerAddress(const QWebSocket* self) { + return new QHostAddress(self->peerAddress()); +} + +struct miqt_string QWebSocket_peerName(const QWebSocket* self) { + QString _ret = self->peerName(); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +unsigned short QWebSocket_peerPort(const QWebSocket* self) { + quint16 _ret = self->peerPort(); + return static_cast(_ret); +} + +QNetworkProxy* QWebSocket_proxy(const QWebSocket* self) { + return new QNetworkProxy(self->proxy()); +} + +void QWebSocket_setProxy(QWebSocket* self, QNetworkProxy* networkProxy) { + self->setProxy(*networkProxy); +} + +void QWebSocket_setMaskGenerator(QWebSocket* self, QMaskGenerator* maskGenerator) { + self->setMaskGenerator(maskGenerator); +} + +QMaskGenerator* QWebSocket_maskGenerator(const QWebSocket* self) { + return (QMaskGenerator*) self->maskGenerator(); +} + +long long QWebSocket_readBufferSize(const QWebSocket* self) { + qint64 _ret = self->readBufferSize(); + return static_cast(_ret); +} + +void QWebSocket_setReadBufferSize(QWebSocket* self, long long size) { + self->setReadBufferSize(static_cast(size)); +} + +void QWebSocket_resume(QWebSocket* self) { + self->resume(); +} + +void QWebSocket_setPauseMode(QWebSocket* self, int pauseMode) { + self->setPauseMode(static_cast(pauseMode)); +} + +int QWebSocket_state(const QWebSocket* self) { + QAbstractSocket::SocketState _ret = self->state(); + return static_cast(_ret); +} + +int QWebSocket_version(const QWebSocket* self) { + QWebSocketProtocol::Version _ret = self->version(); + return static_cast(_ret); +} + +struct miqt_string QWebSocket_resourceName(const QWebSocket* self) { + QString _ret = self->resourceName(); + // 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; +} + +QUrl* QWebSocket_requestUrl(const QWebSocket* self) { + return new QUrl(self->requestUrl()); +} + +QNetworkRequest* QWebSocket_request(const QWebSocket* self) { + return new QNetworkRequest(self->request()); +} + +struct miqt_string QWebSocket_origin(const QWebSocket* self) { + QString _ret = self->origin(); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +int QWebSocket_closeCode(const QWebSocket* self) { + QWebSocketProtocol::CloseCode _ret = self->closeCode(); + return static_cast(_ret); +} + +struct miqt_string QWebSocket_closeReason(const QWebSocket* self) { + QString _ret = self->closeReason(); + // 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; +} + +long long QWebSocket_sendTextMessage(QWebSocket* self, struct miqt_string message) { + QString message_QString = QString::fromUtf8(message.data, message.len); + qint64 _ret = self->sendTextMessage(message_QString); + return static_cast(_ret); +} + +long long QWebSocket_sendBinaryMessage(QWebSocket* self, struct miqt_string data) { + QByteArray data_QByteArray(data.data, data.len); + qint64 _ret = self->sendBinaryMessage(data_QByteArray); + return static_cast(_ret); +} + +void QWebSocket_ignoreSslErrors(QWebSocket* self, struct miqt_array /* of QSslError* */ errors) { + QList errors_QList; + errors_QList.reserve(errors.len); + QSslError** errors_arr = static_cast(errors.data); + for(size_t i = 0; i < errors.len; ++i) { + errors_QList.push_back(*(errors_arr[i])); + } + self->ignoreSslErrors(errors_QList); +} + +void QWebSocket_setSslConfiguration(QWebSocket* self, QSslConfiguration* sslConfiguration) { + self->setSslConfiguration(*sslConfiguration); +} + +QSslConfiguration* QWebSocket_sslConfiguration(const QWebSocket* self) { + return new QSslConfiguration(self->sslConfiguration()); +} + +long long QWebSocket_bytesToWrite(const QWebSocket* self) { + qint64 _ret = self->bytesToWrite(); + return static_cast(_ret); +} + +void QWebSocket_setMaxAllowedIncomingFrameSize(QWebSocket* self, unsigned long long maxAllowedIncomingFrameSize) { + self->setMaxAllowedIncomingFrameSize(static_cast(maxAllowedIncomingFrameSize)); +} + +unsigned long long QWebSocket_maxAllowedIncomingFrameSize(const QWebSocket* self) { + quint64 _ret = self->maxAllowedIncomingFrameSize(); + return static_cast(_ret); +} + +void QWebSocket_setMaxAllowedIncomingMessageSize(QWebSocket* self, unsigned long long maxAllowedIncomingMessageSize) { + self->setMaxAllowedIncomingMessageSize(static_cast(maxAllowedIncomingMessageSize)); +} + +unsigned long long QWebSocket_maxAllowedIncomingMessageSize(const QWebSocket* self) { + quint64 _ret = self->maxAllowedIncomingMessageSize(); + return static_cast(_ret); +} + +unsigned long long QWebSocket_maxIncomingMessageSize() { + quint64 _ret = QWebSocket::maxIncomingMessageSize(); + return static_cast(_ret); +} + +unsigned long long QWebSocket_maxIncomingFrameSize() { + quint64 _ret = QWebSocket::maxIncomingFrameSize(); + return static_cast(_ret); +} + +void QWebSocket_setOutgoingFrameSize(QWebSocket* self, unsigned long long outgoingFrameSize) { + self->setOutgoingFrameSize(static_cast(outgoingFrameSize)); +} + +unsigned long long QWebSocket_outgoingFrameSize(const QWebSocket* self) { + quint64 _ret = self->outgoingFrameSize(); + return static_cast(_ret); +} + +unsigned long long QWebSocket_maxOutgoingFrameSize() { + quint64 _ret = QWebSocket::maxOutgoingFrameSize(); + return static_cast(_ret); +} + +void QWebSocket_close(QWebSocket* self) { + self->close(); +} + +void QWebSocket_open(QWebSocket* self, QUrl* url) { + self->open(*url); +} + +void QWebSocket_openWithRequest(QWebSocket* self, QNetworkRequest* request) { + self->open(*request); +} + +void QWebSocket_ping(QWebSocket* self) { + self->ping(); +} + +void QWebSocket_ignoreSslErrors2(QWebSocket* self) { + self->ignoreSslErrors(); +} + +void QWebSocket_aboutToClose(QWebSocket* self) { + self->aboutToClose(); +} + +void QWebSocket_connect_aboutToClose(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::aboutToClose), self, [=]() { + miqt_exec_callback_QWebSocket_aboutToClose(slot); + }); +} + +void QWebSocket_connected(QWebSocket* self) { + self->connected(); +} + +void QWebSocket_connect_connected(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::connected), self, [=]() { + miqt_exec_callback_QWebSocket_connected(slot); + }); +} + +void QWebSocket_disconnected(QWebSocket* self) { + self->disconnected(); +} + +void QWebSocket_connect_disconnected(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::disconnected), self, [=]() { + miqt_exec_callback_QWebSocket_disconnected(slot); + }); +} + +void QWebSocket_stateChanged(QWebSocket* self, int state) { + self->stateChanged(static_cast(state)); +} + +void QWebSocket_connect_stateChanged(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::stateChanged), self, [=](QAbstractSocket::SocketState state) { + QAbstractSocket::SocketState state_ret = state; + int sigval1 = static_cast(state_ret); + miqt_exec_callback_QWebSocket_stateChanged(slot, sigval1); + }); +} + +void QWebSocket_proxyAuthenticationRequired(QWebSocket* self, QNetworkProxy* proxy, QAuthenticator* pAuthenticator) { + self->proxyAuthenticationRequired(*proxy, pAuthenticator); +} + +void QWebSocket_connect_proxyAuthenticationRequired(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::proxyAuthenticationRequired), self, [=](const QNetworkProxy& proxy, QAuthenticator* pAuthenticator) { + const QNetworkProxy& proxy_ret = proxy; + // Cast returned reference into pointer + QNetworkProxy* sigval1 = const_cast(&proxy_ret); + QAuthenticator* sigval2 = pAuthenticator; + miqt_exec_callback_QWebSocket_proxyAuthenticationRequired(slot, sigval1, sigval2); + }); +} + +void QWebSocket_readChannelFinished(QWebSocket* self) { + self->readChannelFinished(); +} + +void QWebSocket_connect_readChannelFinished(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::readChannelFinished), self, [=]() { + miqt_exec_callback_QWebSocket_readChannelFinished(slot); + }); +} + +void QWebSocket_textFrameReceived(QWebSocket* self, struct miqt_string frame, bool isLastFrame) { + QString frame_QString = QString::fromUtf8(frame.data, frame.len); + self->textFrameReceived(frame_QString, isLastFrame); +} + +void QWebSocket_connect_textFrameReceived(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::textFrameReceived), self, [=](const QString& frame, bool isLastFrame) { + const QString frame_ret = frame; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray frame_b = frame_ret.toUtf8(); + struct miqt_string frame_ms; + frame_ms.len = frame_b.length(); + frame_ms.data = static_cast(malloc(frame_ms.len)); + memcpy(frame_ms.data, frame_b.data(), frame_ms.len); + struct miqt_string sigval1 = frame_ms; + bool sigval2 = isLastFrame; + miqt_exec_callback_QWebSocket_textFrameReceived(slot, sigval1, sigval2); + }); +} + +void QWebSocket_binaryFrameReceived(QWebSocket* self, struct miqt_string frame, bool isLastFrame) { + QByteArray frame_QByteArray(frame.data, frame.len); + self->binaryFrameReceived(frame_QByteArray, isLastFrame); +} + +void QWebSocket_connect_binaryFrameReceived(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::binaryFrameReceived), self, [=](const QByteArray& frame, bool isLastFrame) { + const QByteArray frame_qb = frame; + struct miqt_string frame_ms; + frame_ms.len = frame_qb.length(); + frame_ms.data = static_cast(malloc(frame_ms.len)); + memcpy(frame_ms.data, frame_qb.data(), frame_ms.len); + struct miqt_string sigval1 = frame_ms; + bool sigval2 = isLastFrame; + miqt_exec_callback_QWebSocket_binaryFrameReceived(slot, sigval1, sigval2); + }); +} + +void QWebSocket_textMessageReceived(QWebSocket* self, struct miqt_string message) { + QString message_QString = QString::fromUtf8(message.data, message.len); + self->textMessageReceived(message_QString); +} + +void QWebSocket_connect_textMessageReceived(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::textMessageReceived), self, [=](const QString& message) { + const QString message_ret = message; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray message_b = message_ret.toUtf8(); + struct miqt_string message_ms; + message_ms.len = message_b.length(); + message_ms.data = static_cast(malloc(message_ms.len)); + memcpy(message_ms.data, message_b.data(), message_ms.len); + struct miqt_string sigval1 = message_ms; + miqt_exec_callback_QWebSocket_textMessageReceived(slot, sigval1); + }); +} + +void QWebSocket_binaryMessageReceived(QWebSocket* self, struct miqt_string message) { + QByteArray message_QByteArray(message.data, message.len); + self->binaryMessageReceived(message_QByteArray); +} + +void QWebSocket_connect_binaryMessageReceived(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::binaryMessageReceived), self, [=](const QByteArray& message) { + const QByteArray message_qb = message; + struct miqt_string message_ms; + message_ms.len = message_qb.length(); + message_ms.data = static_cast(malloc(message_ms.len)); + memcpy(message_ms.data, message_qb.data(), message_ms.len); + struct miqt_string sigval1 = message_ms; + miqt_exec_callback_QWebSocket_binaryMessageReceived(slot, sigval1); + }); +} + +void QWebSocket_errorWithError(QWebSocket* self, int error) { + self->error(static_cast(error)); +} + +void QWebSocket_connect_errorWithError(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::error), self, [=](QAbstractSocket::SocketError error) { + QAbstractSocket::SocketError error_ret = error; + int sigval1 = static_cast(error_ret); + miqt_exec_callback_QWebSocket_errorWithError(slot, sigval1); + }); +} + +void QWebSocket_pong(QWebSocket* self, unsigned long long elapsedTime, struct miqt_string payload) { + QByteArray payload_QByteArray(payload.data, payload.len); + self->pong(static_cast(elapsedTime), payload_QByteArray); +} + +void QWebSocket_connect_pong(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::pong), self, [=](quint64 elapsedTime, const QByteArray& payload) { + quint64 elapsedTime_ret = elapsedTime; + unsigned long long sigval1 = static_cast(elapsedTime_ret); + const QByteArray payload_qb = payload; + struct miqt_string payload_ms; + payload_ms.len = payload_qb.length(); + payload_ms.data = static_cast(malloc(payload_ms.len)); + memcpy(payload_ms.data, payload_qb.data(), payload_ms.len); + struct miqt_string sigval2 = payload_ms; + miqt_exec_callback_QWebSocket_pong(slot, sigval1, sigval2); + }); +} + +void QWebSocket_bytesWritten(QWebSocket* self, long long bytes) { + self->bytesWritten(static_cast(bytes)); +} + +void QWebSocket_connect_bytesWritten(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::bytesWritten), self, [=](qint64 bytes) { + qint64 bytes_ret = bytes; + long long sigval1 = static_cast(bytes_ret); + miqt_exec_callback_QWebSocket_bytesWritten(slot, sigval1); + }); +} + +void QWebSocket_sslErrors(QWebSocket* self, struct miqt_array /* of QSslError* */ errors) { + QList errors_QList; + errors_QList.reserve(errors.len); + QSslError** errors_arr = static_cast(errors.data); + for(size_t i = 0; i < errors.len; ++i) { + errors_QList.push_back(*(errors_arr[i])); + } + self->sslErrors(errors_QList); +} + +void QWebSocket_connect_sslErrors(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast&)>(&QWebSocket::sslErrors), self, [=](const QList& errors) { + const QList& errors_ret = errors; + // Convert QList<> from C++ memory to manually-managed C memory + QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.length())); + for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { + errors_arr[i] = new QSslError(errors_ret[i]); + } + struct miqt_array errors_out; + errors_out.len = errors_ret.length(); + errors_out.data = static_cast(errors_arr); + struct miqt_array /* of QSslError* */ sigval1 = errors_out; + miqt_exec_callback_QWebSocket_sslErrors(slot, sigval1); + }); +} + +void QWebSocket_preSharedKeyAuthenticationRequired(QWebSocket* self, QSslPreSharedKeyAuthenticator* authenticator) { + self->preSharedKeyAuthenticationRequired(authenticator); +} + +void QWebSocket_connect_preSharedKeyAuthenticationRequired(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::preSharedKeyAuthenticationRequired), self, [=](QSslPreSharedKeyAuthenticator* authenticator) { + QSslPreSharedKeyAuthenticator* sigval1 = authenticator; + miqt_exec_callback_QWebSocket_preSharedKeyAuthenticationRequired(slot, sigval1); + }); +} + +struct miqt_string QWebSocket_tr2(const char* s, const char* c) { + QString _ret = QWebSocket::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 QWebSocket_tr3(const char* s, const char* c, int n) { + QString _ret = QWebSocket::tr(s, c, static_cast(n)); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string QWebSocket_trUtf82(const char* s, const char* c) { + QString _ret = QWebSocket::trUtf8(s, c); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string QWebSocket_trUtf83(const char* s, const char* c, int n) { + QString _ret = QWebSocket::trUtf8(s, c, static_cast(n)); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +void QWebSocket_closeWithCloseCode(QWebSocket* self, int closeCode) { + self->close(static_cast(closeCode)); +} + +void QWebSocket_close2(QWebSocket* self, int closeCode, struct miqt_string reason) { + QString reason_QString = QString::fromUtf8(reason.data, reason.len); + self->close(static_cast(closeCode), reason_QString); +} + +void QWebSocket_pingWithPayload(QWebSocket* self, struct miqt_string payload) { + QByteArray payload_QByteArray(payload.data, payload.len); + self->ping(payload_QByteArray); +} + +bool QWebSocket_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QWebSocket_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QWebSocket::event(event); +} + +bool QWebSocket_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QWebSocket_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QWebSocket::eventFilter(watched, event); +} + +bool QWebSocket_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QWebSocket_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QWebSocket::timerEvent(event); +} + +bool QWebSocket_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QWebSocket_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QWebSocket::childEvent(event); +} + +bool QWebSocket_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QWebSocket_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QWebSocket::customEvent(event); +} + +bool QWebSocket_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QWebSocket_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QWebSocket::connectNotify(*signal); +} + +bool QWebSocket_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QWebSocket_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QWebSocket::disconnectNotify(*signal); +} + +QObject* QWebSocket_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QWebSocket_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QWebSocket_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QWebSocket_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QWebSocket_delete(QWebSocket* self) { + delete self; +} + diff --git a/qt/websockets/gen_qwebsocket.go b/qt/websockets/gen_qwebsocket.go new file mode 100644 index 000000000..377346fe6 --- /dev/null +++ b/qt/websockets/gen_qwebsocket.go @@ -0,0 +1,1028 @@ +package websockets + +/* + +#include "gen_qwebsocket.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "github.com/mappu/miqt/qt/network" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QWebSocket struct { + h *C.QWebSocket + *qt.QObject +} + +func (this *QWebSocket) cPointer() *C.QWebSocket { + if this == nil { + return nil + } + return this.h +} + +func (this *QWebSocket) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQWebSocket constructs the type using only CGO pointers. +func newQWebSocket(h *C.QWebSocket) *QWebSocket { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QWebSocket_virtbase(h, &outptr_QObject) + + return &QWebSocket{h: h, + QObject: qt.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQWebSocket constructs the type using only unsafe pointers. +func UnsafeNewQWebSocket(h unsafe.Pointer) *QWebSocket { + return newQWebSocket((*C.QWebSocket)(h)) +} + +// NewQWebSocket constructs a new QWebSocket object. +func NewQWebSocket() *QWebSocket { + + return newQWebSocket(C.QWebSocket_new()) +} + +// NewQWebSocket2 constructs a new QWebSocket object. +func NewQWebSocket2(origin string) *QWebSocket { + origin_ms := C.struct_miqt_string{} + origin_ms.data = C.CString(origin) + origin_ms.len = C.size_t(len(origin)) + defer C.free(unsafe.Pointer(origin_ms.data)) + + return newQWebSocket(C.QWebSocket_new2(origin_ms)) +} + +// NewQWebSocket3 constructs a new QWebSocket object. +func NewQWebSocket3(origin string, version QWebSocketProtocol__Version) *QWebSocket { + origin_ms := C.struct_miqt_string{} + origin_ms.data = C.CString(origin) + origin_ms.len = C.size_t(len(origin)) + defer C.free(unsafe.Pointer(origin_ms.data)) + + return newQWebSocket(C.QWebSocket_new3(origin_ms, (C.int)(version))) +} + +// NewQWebSocket4 constructs a new QWebSocket object. +func NewQWebSocket4(origin string, version QWebSocketProtocol__Version, parent *qt.QObject) *QWebSocket { + origin_ms := C.struct_miqt_string{} + origin_ms.data = C.CString(origin) + origin_ms.len = C.size_t(len(origin)) + defer C.free(unsafe.Pointer(origin_ms.data)) + + return newQWebSocket(C.QWebSocket_new4(origin_ms, (C.int)(version), (*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QWebSocket) MetaObject() *qt.QMetaObject { + return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QWebSocket_metaObject(this.h))) +} + +func (this *QWebSocket) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QWebSocket_metacast(this.h, param1_Cstring)) +} + +func QWebSocket_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QWebSocket_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QWebSocket_TrUtf8(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QWebSocket_trUtf8(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) Abort() { + C.QWebSocket_abort(this.h) +} + +func (this *QWebSocket) Error() network.QAbstractSocket__SocketError { + return (network.QAbstractSocket__SocketError)(C.QWebSocket_error(this.h)) +} + +func (this *QWebSocket) ErrorString() string { + var _ms C.struct_miqt_string = C.QWebSocket_errorString(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) Flush() bool { + return (bool)(C.QWebSocket_flush(this.h)) +} + +func (this *QWebSocket) IsValid() bool { + return (bool)(C.QWebSocket_isValid(this.h)) +} + +func (this *QWebSocket) LocalAddress() *network.QHostAddress { + _goptr := network.UnsafeNewQHostAddress(unsafe.Pointer(C.QWebSocket_localAddress(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) LocalPort() uint16 { + return (uint16)(C.QWebSocket_localPort(this.h)) +} + +func (this *QWebSocket) PauseMode() network.QAbstractSocket__PauseMode { + return (network.QAbstractSocket__PauseMode)(C.QWebSocket_pauseMode(this.h)) +} + +func (this *QWebSocket) PeerAddress() *network.QHostAddress { + _goptr := network.UnsafeNewQHostAddress(unsafe.Pointer(C.QWebSocket_peerAddress(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) PeerName() string { + var _ms C.struct_miqt_string = C.QWebSocket_peerName(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) PeerPort() uint16 { + return (uint16)(C.QWebSocket_peerPort(this.h)) +} + +func (this *QWebSocket) Proxy() *network.QNetworkProxy { + _goptr := network.UnsafeNewQNetworkProxy(unsafe.Pointer(C.QWebSocket_proxy(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) SetProxy(networkProxy *network.QNetworkProxy) { + C.QWebSocket_setProxy(this.h, (*C.QNetworkProxy)(networkProxy.UnsafePointer())) +} + +func (this *QWebSocket) SetMaskGenerator(maskGenerator *QMaskGenerator) { + C.QWebSocket_setMaskGenerator(this.h, maskGenerator.cPointer()) +} + +func (this *QWebSocket) MaskGenerator() *QMaskGenerator { + return newQMaskGenerator(C.QWebSocket_maskGenerator(this.h)) +} + +func (this *QWebSocket) ReadBufferSize() int64 { + return (int64)(C.QWebSocket_readBufferSize(this.h)) +} + +func (this *QWebSocket) SetReadBufferSize(size int64) { + C.QWebSocket_setReadBufferSize(this.h, (C.longlong)(size)) +} + +func (this *QWebSocket) Resume() { + C.QWebSocket_resume(this.h) +} + +func (this *QWebSocket) SetPauseMode(pauseMode network.QAbstractSocket__PauseMode) { + C.QWebSocket_setPauseMode(this.h, (C.int)(pauseMode)) +} + +func (this *QWebSocket) State() network.QAbstractSocket__SocketState { + return (network.QAbstractSocket__SocketState)(C.QWebSocket_state(this.h)) +} + +func (this *QWebSocket) Version() QWebSocketProtocol__Version { + return (QWebSocketProtocol__Version)(C.QWebSocket_version(this.h)) +} + +func (this *QWebSocket) ResourceName() string { + var _ms C.struct_miqt_string = C.QWebSocket_resourceName(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) RequestUrl() *qt.QUrl { + _goptr := qt.UnsafeNewQUrl(unsafe.Pointer(C.QWebSocket_requestUrl(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) Request() *network.QNetworkRequest { + _goptr := network.UnsafeNewQNetworkRequest(unsafe.Pointer(C.QWebSocket_request(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) Origin() string { + var _ms C.struct_miqt_string = C.QWebSocket_origin(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) CloseCode() QWebSocketProtocol__CloseCode { + return (QWebSocketProtocol__CloseCode)(C.QWebSocket_closeCode(this.h)) +} + +func (this *QWebSocket) CloseReason() string { + var _ms C.struct_miqt_string = C.QWebSocket_closeReason(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) SendTextMessage(message string) int64 { + message_ms := C.struct_miqt_string{} + message_ms.data = C.CString(message) + message_ms.len = C.size_t(len(message)) + defer C.free(unsafe.Pointer(message_ms.data)) + return (int64)(C.QWebSocket_sendTextMessage(this.h, message_ms)) +} + +func (this *QWebSocket) SendBinaryMessage(data []byte) int64 { + data_alias := C.struct_miqt_string{} + if len(data) > 0 { + data_alias.data = (*C.char)(unsafe.Pointer(&data[0])) + } else { + data_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + data_alias.len = C.size_t(len(data)) + return (int64)(C.QWebSocket_sendBinaryMessage(this.h, data_alias)) +} + +func (this *QWebSocket) IgnoreSslErrors(errors []network.QSslError) { + errors_CArray := (*[0xffff]*C.QSslError)(C.malloc(C.size_t(8 * len(errors)))) + defer C.free(unsafe.Pointer(errors_CArray)) + for i := range errors { + errors_CArray[i] = (*C.QSslError)(errors[i].UnsafePointer()) + } + errors_ma := C.struct_miqt_array{len: C.size_t(len(errors)), data: unsafe.Pointer(errors_CArray)} + C.QWebSocket_ignoreSslErrors(this.h, errors_ma) +} + +func (this *QWebSocket) SetSslConfiguration(sslConfiguration *network.QSslConfiguration) { + C.QWebSocket_setSslConfiguration(this.h, (*C.QSslConfiguration)(sslConfiguration.UnsafePointer())) +} + +func (this *QWebSocket) SslConfiguration() *network.QSslConfiguration { + _goptr := network.UnsafeNewQSslConfiguration(unsafe.Pointer(C.QWebSocket_sslConfiguration(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) BytesToWrite() int64 { + return (int64)(C.QWebSocket_bytesToWrite(this.h)) +} + +func (this *QWebSocket) SetMaxAllowedIncomingFrameSize(maxAllowedIncomingFrameSize uint64) { + C.QWebSocket_setMaxAllowedIncomingFrameSize(this.h, (C.ulonglong)(maxAllowedIncomingFrameSize)) +} + +func (this *QWebSocket) MaxAllowedIncomingFrameSize() uint64 { + return (uint64)(C.QWebSocket_maxAllowedIncomingFrameSize(this.h)) +} + +func (this *QWebSocket) SetMaxAllowedIncomingMessageSize(maxAllowedIncomingMessageSize uint64) { + C.QWebSocket_setMaxAllowedIncomingMessageSize(this.h, (C.ulonglong)(maxAllowedIncomingMessageSize)) +} + +func (this *QWebSocket) MaxAllowedIncomingMessageSize() uint64 { + return (uint64)(C.QWebSocket_maxAllowedIncomingMessageSize(this.h)) +} + +func QWebSocket_MaxIncomingMessageSize() uint64 { + return (uint64)(C.QWebSocket_maxIncomingMessageSize()) +} + +func QWebSocket_MaxIncomingFrameSize() uint64 { + return (uint64)(C.QWebSocket_maxIncomingFrameSize()) +} + +func (this *QWebSocket) SetOutgoingFrameSize(outgoingFrameSize uint64) { + C.QWebSocket_setOutgoingFrameSize(this.h, (C.ulonglong)(outgoingFrameSize)) +} + +func (this *QWebSocket) OutgoingFrameSize() uint64 { + return (uint64)(C.QWebSocket_outgoingFrameSize(this.h)) +} + +func QWebSocket_MaxOutgoingFrameSize() uint64 { + return (uint64)(C.QWebSocket_maxOutgoingFrameSize()) +} + +func (this *QWebSocket) Close() { + C.QWebSocket_close(this.h) +} + +func (this *QWebSocket) Open(url *qt.QUrl) { + C.QWebSocket_open(this.h, (*C.QUrl)(url.UnsafePointer())) +} + +func (this *QWebSocket) OpenWithRequest(request *network.QNetworkRequest) { + C.QWebSocket_openWithRequest(this.h, (*C.QNetworkRequest)(request.UnsafePointer())) +} + +func (this *QWebSocket) Ping() { + C.QWebSocket_ping(this.h) +} + +func (this *QWebSocket) IgnoreSslErrors2() { + C.QWebSocket_ignoreSslErrors2(this.h) +} + +func (this *QWebSocket) AboutToClose() { + C.QWebSocket_aboutToClose(this.h) +} +func (this *QWebSocket) OnAboutToClose(slot func()) { + C.QWebSocket_connect_aboutToClose(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_aboutToClose +func miqt_exec_callback_QWebSocket_aboutToClose(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 *QWebSocket) Connected() { + C.QWebSocket_connected(this.h) +} +func (this *QWebSocket) OnConnected(slot func()) { + C.QWebSocket_connect_connected(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_connected +func miqt_exec_callback_QWebSocket_connected(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 *QWebSocket) Disconnected() { + C.QWebSocket_disconnected(this.h) +} +func (this *QWebSocket) OnDisconnected(slot func()) { + C.QWebSocket_connect_disconnected(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_disconnected +func miqt_exec_callback_QWebSocket_disconnected(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 *QWebSocket) StateChanged(state network.QAbstractSocket__SocketState) { + C.QWebSocket_stateChanged(this.h, (C.int)(state)) +} +func (this *QWebSocket) OnStateChanged(slot func(state network.QAbstractSocket__SocketState)) { + C.QWebSocket_connect_stateChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_stateChanged +func miqt_exec_callback_QWebSocket_stateChanged(cb C.intptr_t, state C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(state network.QAbstractSocket__SocketState)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (network.QAbstractSocket__SocketState)(state) + + gofunc(slotval1) +} + +func (this *QWebSocket) ProxyAuthenticationRequired(proxy *network.QNetworkProxy, pAuthenticator *network.QAuthenticator) { + C.QWebSocket_proxyAuthenticationRequired(this.h, (*C.QNetworkProxy)(proxy.UnsafePointer()), (*C.QAuthenticator)(pAuthenticator.UnsafePointer())) +} +func (this *QWebSocket) OnProxyAuthenticationRequired(slot func(proxy *network.QNetworkProxy, pAuthenticator *network.QAuthenticator)) { + C.QWebSocket_connect_proxyAuthenticationRequired(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_proxyAuthenticationRequired +func miqt_exec_callback_QWebSocket_proxyAuthenticationRequired(cb C.intptr_t, proxy *C.QNetworkProxy, pAuthenticator *C.QAuthenticator) { + gofunc, ok := cgo.Handle(cb).Value().(func(proxy *network.QNetworkProxy, pAuthenticator *network.QAuthenticator)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := network.UnsafeNewQNetworkProxy(unsafe.Pointer(proxy)) + + slotval2 := network.UnsafeNewQAuthenticator(unsafe.Pointer(pAuthenticator)) + + gofunc(slotval1, slotval2) +} + +func (this *QWebSocket) ReadChannelFinished() { + C.QWebSocket_readChannelFinished(this.h) +} +func (this *QWebSocket) OnReadChannelFinished(slot func()) { + C.QWebSocket_connect_readChannelFinished(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_readChannelFinished +func miqt_exec_callback_QWebSocket_readChannelFinished(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 *QWebSocket) TextFrameReceived(frame string, isLastFrame bool) { + frame_ms := C.struct_miqt_string{} + frame_ms.data = C.CString(frame) + frame_ms.len = C.size_t(len(frame)) + defer C.free(unsafe.Pointer(frame_ms.data)) + C.QWebSocket_textFrameReceived(this.h, frame_ms, (C.bool)(isLastFrame)) +} +func (this *QWebSocket) OnTextFrameReceived(slot func(frame string, isLastFrame bool)) { + C.QWebSocket_connect_textFrameReceived(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_textFrameReceived +func miqt_exec_callback_QWebSocket_textFrameReceived(cb C.intptr_t, frame C.struct_miqt_string, isLastFrame C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(frame string, isLastFrame bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var frame_ms C.struct_miqt_string = frame + frame_ret := C.GoStringN(frame_ms.data, C.int(int64(frame_ms.len))) + C.free(unsafe.Pointer(frame_ms.data)) + slotval1 := frame_ret + slotval2 := (bool)(isLastFrame) + + gofunc(slotval1, slotval2) +} + +func (this *QWebSocket) BinaryFrameReceived(frame []byte, isLastFrame bool) { + frame_alias := C.struct_miqt_string{} + if len(frame) > 0 { + frame_alias.data = (*C.char)(unsafe.Pointer(&frame[0])) + } else { + frame_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + frame_alias.len = C.size_t(len(frame)) + C.QWebSocket_binaryFrameReceived(this.h, frame_alias, (C.bool)(isLastFrame)) +} +func (this *QWebSocket) OnBinaryFrameReceived(slot func(frame []byte, isLastFrame bool)) { + C.QWebSocket_connect_binaryFrameReceived(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_binaryFrameReceived +func miqt_exec_callback_QWebSocket_binaryFrameReceived(cb C.intptr_t, frame C.struct_miqt_string, isLastFrame C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(frame []byte, isLastFrame bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var frame_bytearray C.struct_miqt_string = frame + frame_ret := C.GoBytes(unsafe.Pointer(frame_bytearray.data), C.int(int64(frame_bytearray.len))) + C.free(unsafe.Pointer(frame_bytearray.data)) + slotval1 := frame_ret + slotval2 := (bool)(isLastFrame) + + gofunc(slotval1, slotval2) +} + +func (this *QWebSocket) TextMessageReceived(message string) { + message_ms := C.struct_miqt_string{} + message_ms.data = C.CString(message) + message_ms.len = C.size_t(len(message)) + defer C.free(unsafe.Pointer(message_ms.data)) + C.QWebSocket_textMessageReceived(this.h, message_ms) +} +func (this *QWebSocket) OnTextMessageReceived(slot func(message string)) { + C.QWebSocket_connect_textMessageReceived(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_textMessageReceived +func miqt_exec_callback_QWebSocket_textMessageReceived(cb C.intptr_t, message C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(message string)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var message_ms C.struct_miqt_string = message + message_ret := C.GoStringN(message_ms.data, C.int(int64(message_ms.len))) + C.free(unsafe.Pointer(message_ms.data)) + slotval1 := message_ret + + gofunc(slotval1) +} + +func (this *QWebSocket) BinaryMessageReceived(message []byte) { + message_alias := C.struct_miqt_string{} + if len(message) > 0 { + message_alias.data = (*C.char)(unsafe.Pointer(&message[0])) + } else { + message_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + message_alias.len = C.size_t(len(message)) + C.QWebSocket_binaryMessageReceived(this.h, message_alias) +} +func (this *QWebSocket) OnBinaryMessageReceived(slot func(message []byte)) { + C.QWebSocket_connect_binaryMessageReceived(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_binaryMessageReceived +func miqt_exec_callback_QWebSocket_binaryMessageReceived(cb C.intptr_t, message C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(message []byte)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var message_bytearray C.struct_miqt_string = message + message_ret := C.GoBytes(unsafe.Pointer(message_bytearray.data), C.int(int64(message_bytearray.len))) + C.free(unsafe.Pointer(message_bytearray.data)) + slotval1 := message_ret + + gofunc(slotval1) +} + +func (this *QWebSocket) ErrorWithError(error network.QAbstractSocket__SocketError) { + C.QWebSocket_errorWithError(this.h, (C.int)(error)) +} +func (this *QWebSocket) OnErrorWithError(slot func(error network.QAbstractSocket__SocketError)) { + C.QWebSocket_connect_errorWithError(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_errorWithError +func miqt_exec_callback_QWebSocket_errorWithError(cb C.intptr_t, error C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(error network.QAbstractSocket__SocketError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (network.QAbstractSocket__SocketError)(error) + + gofunc(slotval1) +} + +func (this *QWebSocket) Pong(elapsedTime uint64, payload []byte) { + payload_alias := C.struct_miqt_string{} + if len(payload) > 0 { + payload_alias.data = (*C.char)(unsafe.Pointer(&payload[0])) + } else { + payload_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + payload_alias.len = C.size_t(len(payload)) + C.QWebSocket_pong(this.h, (C.ulonglong)(elapsedTime), payload_alias) +} +func (this *QWebSocket) OnPong(slot func(elapsedTime uint64, payload []byte)) { + C.QWebSocket_connect_pong(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_pong +func miqt_exec_callback_QWebSocket_pong(cb C.intptr_t, elapsedTime C.ulonglong, payload C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(elapsedTime uint64, payload []byte)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (uint64)(elapsedTime) + + var payload_bytearray C.struct_miqt_string = payload + payload_ret := C.GoBytes(unsafe.Pointer(payload_bytearray.data), C.int(int64(payload_bytearray.len))) + C.free(unsafe.Pointer(payload_bytearray.data)) + slotval2 := payload_ret + + gofunc(slotval1, slotval2) +} + +func (this *QWebSocket) BytesWritten(bytes int64) { + C.QWebSocket_bytesWritten(this.h, (C.longlong)(bytes)) +} +func (this *QWebSocket) OnBytesWritten(slot func(bytes int64)) { + C.QWebSocket_connect_bytesWritten(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_bytesWritten +func miqt_exec_callback_QWebSocket_bytesWritten(cb C.intptr_t, bytes C.longlong) { + gofunc, ok := cgo.Handle(cb).Value().(func(bytes int64)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int64)(bytes) + + gofunc(slotval1) +} + +func (this *QWebSocket) SslErrors(errors []network.QSslError) { + errors_CArray := (*[0xffff]*C.QSslError)(C.malloc(C.size_t(8 * len(errors)))) + defer C.free(unsafe.Pointer(errors_CArray)) + for i := range errors { + errors_CArray[i] = (*C.QSslError)(errors[i].UnsafePointer()) + } + errors_ma := C.struct_miqt_array{len: C.size_t(len(errors)), data: unsafe.Pointer(errors_CArray)} + C.QWebSocket_sslErrors(this.h, errors_ma) +} +func (this *QWebSocket) OnSslErrors(slot func(errors []network.QSslError)) { + C.QWebSocket_connect_sslErrors(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_sslErrors +func miqt_exec_callback_QWebSocket_sslErrors(cb C.intptr_t, errors C.struct_miqt_array) { + gofunc, ok := cgo.Handle(cb).Value().(func(errors []network.QSslError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var errors_ma C.struct_miqt_array = errors + errors_ret := make([]network.QSslError, int(errors_ma.len)) + errors_outCast := (*[0xffff]*C.QSslError)(unsafe.Pointer(errors_ma.data)) // hey ya + for i := 0; i < int(errors_ma.len); i++ { + errors_lv_goptr := network.UnsafeNewQSslError(unsafe.Pointer(errors_outCast[i])) + errors_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + errors_ret[i] = *errors_lv_goptr + } + slotval1 := errors_ret + + gofunc(slotval1) +} + +func (this *QWebSocket) PreSharedKeyAuthenticationRequired(authenticator *network.QSslPreSharedKeyAuthenticator) { + C.QWebSocket_preSharedKeyAuthenticationRequired(this.h, (*C.QSslPreSharedKeyAuthenticator)(authenticator.UnsafePointer())) +} +func (this *QWebSocket) OnPreSharedKeyAuthenticationRequired(slot func(authenticator *network.QSslPreSharedKeyAuthenticator)) { + C.QWebSocket_connect_preSharedKeyAuthenticationRequired(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_preSharedKeyAuthenticationRequired +func miqt_exec_callback_QWebSocket_preSharedKeyAuthenticationRequired(cb C.intptr_t, authenticator *C.QSslPreSharedKeyAuthenticator) { + gofunc, ok := cgo.Handle(cb).Value().(func(authenticator *network.QSslPreSharedKeyAuthenticator)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := network.UnsafeNewQSslPreSharedKeyAuthenticator(unsafe.Pointer(authenticator)) + + gofunc(slotval1) +} + +func QWebSocket_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.QWebSocket_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QWebSocket_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.QWebSocket_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 QWebSocket_TrUtf82(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QWebSocket_trUtf82(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QWebSocket_TrUtf83(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QWebSocket_trUtf83(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) CloseWithCloseCode(closeCode QWebSocketProtocol__CloseCode) { + C.QWebSocket_closeWithCloseCode(this.h, (C.int)(closeCode)) +} + +func (this *QWebSocket) Close2(closeCode QWebSocketProtocol__CloseCode, reason string) { + reason_ms := C.struct_miqt_string{} + reason_ms.data = C.CString(reason) + reason_ms.len = C.size_t(len(reason)) + defer C.free(unsafe.Pointer(reason_ms.data)) + C.QWebSocket_close2(this.h, (C.int)(closeCode), reason_ms) +} + +func (this *QWebSocket) PingWithPayload(payload []byte) { + payload_alias := C.struct_miqt_string{} + if len(payload) > 0 { + payload_alias.data = (*C.char)(unsafe.Pointer(&payload[0])) + } else { + payload_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + payload_alias.len = C.size_t(len(payload)) + C.QWebSocket_pingWithPayload(this.h, payload_alias) +} + +// Sender can only be called from a QWebSocket that was directly constructed. +func (this *QWebSocket) Sender() *qt.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt.UnsafeNewQObject(unsafe.Pointer(C.QWebSocket_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 QWebSocket that was directly constructed. +func (this *QWebSocket) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QWebSocket_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 QWebSocket that was directly constructed. +func (this *QWebSocket) 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.QWebSocket_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 QWebSocket that was directly constructed. +func (this *QWebSocket) IsSignalConnected(signal *qt.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QWebSocket_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 *QWebSocket) callVirtualBase_Event(event *qt.QEvent) bool { + + return (bool)(C.QWebSocket_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QWebSocket) OnEvent(slot func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) { + ok := C.QWebSocket_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_QWebSocket_event +func miqt_exec_callback_QWebSocket_event(self *C.QWebSocket, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QWebSocket{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QWebSocket) callVirtualBase_EventFilter(watched *qt.QObject, event *qt.QEvent) bool { + + return (bool)(C.QWebSocket_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QWebSocket) OnEventFilter(slot func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) { + ok := C.QWebSocket_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_QWebSocket_eventFilter +func miqt_exec_callback_QWebSocket_eventFilter(self *C.QWebSocket, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QWebSocket{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QWebSocket) callVirtualBase_TimerEvent(event *qt.QTimerEvent) { + + C.QWebSocket_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QWebSocket) OnTimerEvent(slot func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) { + ok := C.QWebSocket_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_QWebSocket_timerEvent +func miqt_exec_callback_QWebSocket_timerEvent(self *C.QWebSocket, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QWebSocket{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QWebSocket) callVirtualBase_ChildEvent(event *qt.QChildEvent) { + + C.QWebSocket_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QWebSocket) OnChildEvent(slot func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) { + ok := C.QWebSocket_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_QWebSocket_childEvent +func miqt_exec_callback_QWebSocket_childEvent(self *C.QWebSocket, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QWebSocket{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QWebSocket) callVirtualBase_CustomEvent(event *qt.QEvent) { + + C.QWebSocket_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QWebSocket) OnCustomEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) { + ok := C.QWebSocket_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_QWebSocket_customEvent +func miqt_exec_callback_QWebSocket_customEvent(self *C.QWebSocket, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QWebSocket{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QWebSocket) callVirtualBase_ConnectNotify(signal *qt.QMetaMethod) { + + C.QWebSocket_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QWebSocket) OnConnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QWebSocket_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_QWebSocket_connectNotify +func miqt_exec_callback_QWebSocket_connectNotify(self *C.QWebSocket, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QWebSocket{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QWebSocket) callVirtualBase_DisconnectNotify(signal *qt.QMetaMethod) { + + C.QWebSocket_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QWebSocket) OnDisconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QWebSocket_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_QWebSocket_disconnectNotify +func miqt_exec_callback_QWebSocket_disconnectNotify(self *C.QWebSocket, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QWebSocket{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QWebSocket) Delete() { + C.QWebSocket_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 *QWebSocket) GoGC() { + runtime.SetFinalizer(this, func(this *QWebSocket) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/websockets/gen_qwebsocket.h b/qt/websockets/gen_qwebsocket.h new file mode 100644 index 000000000..39c96c776 --- /dev/null +++ b/qt/websockets/gen_qwebsocket.h @@ -0,0 +1,173 @@ +#pragma once +#ifndef MIQT_QT_WEBSOCKETS_GEN_QWEBSOCKET_H +#define MIQT_QT_WEBSOCKETS_GEN_QWEBSOCKET_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAuthenticator; +class QChildEvent; +class QEvent; +class QHostAddress; +class QMaskGenerator; +class QMetaMethod; +class QMetaObject; +class QNetworkProxy; +class QNetworkRequest; +class QObject; +class QSslConfiguration; +class QSslError; +class QSslPreSharedKeyAuthenticator; +class QTimerEvent; +class QUrl; +class QWebSocket; +#else +typedef struct QAuthenticator QAuthenticator; +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QHostAddress QHostAddress; +typedef struct QMaskGenerator QMaskGenerator; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QNetworkProxy QNetworkProxy; +typedef struct QNetworkRequest QNetworkRequest; +typedef struct QObject QObject; +typedef struct QSslConfiguration QSslConfiguration; +typedef struct QSslError QSslError; +typedef struct QSslPreSharedKeyAuthenticator QSslPreSharedKeyAuthenticator; +typedef struct QTimerEvent QTimerEvent; +typedef struct QUrl QUrl; +typedef struct QWebSocket QWebSocket; +#endif + +QWebSocket* QWebSocket_new(); +QWebSocket* QWebSocket_new2(struct miqt_string origin); +QWebSocket* QWebSocket_new3(struct miqt_string origin, int version); +QWebSocket* QWebSocket_new4(struct miqt_string origin, int version, QObject* parent); +void QWebSocket_virtbase(QWebSocket* src, QObject** outptr_QObject); +QMetaObject* QWebSocket_metaObject(const QWebSocket* self); +void* QWebSocket_metacast(QWebSocket* self, const char* param1); +struct miqt_string QWebSocket_tr(const char* s); +struct miqt_string QWebSocket_trUtf8(const char* s); +void QWebSocket_abort(QWebSocket* self); +int QWebSocket_error(const QWebSocket* self); +struct miqt_string QWebSocket_errorString(const QWebSocket* self); +bool QWebSocket_flush(QWebSocket* self); +bool QWebSocket_isValid(const QWebSocket* self); +QHostAddress* QWebSocket_localAddress(const QWebSocket* self); +unsigned short QWebSocket_localPort(const QWebSocket* self); +int QWebSocket_pauseMode(const QWebSocket* self); +QHostAddress* QWebSocket_peerAddress(const QWebSocket* self); +struct miqt_string QWebSocket_peerName(const QWebSocket* self); +unsigned short QWebSocket_peerPort(const QWebSocket* self); +QNetworkProxy* QWebSocket_proxy(const QWebSocket* self); +void QWebSocket_setProxy(QWebSocket* self, QNetworkProxy* networkProxy); +void QWebSocket_setMaskGenerator(QWebSocket* self, QMaskGenerator* maskGenerator); +QMaskGenerator* QWebSocket_maskGenerator(const QWebSocket* self); +long long QWebSocket_readBufferSize(const QWebSocket* self); +void QWebSocket_setReadBufferSize(QWebSocket* self, long long size); +void QWebSocket_resume(QWebSocket* self); +void QWebSocket_setPauseMode(QWebSocket* self, int pauseMode); +int QWebSocket_state(const QWebSocket* self); +int QWebSocket_version(const QWebSocket* self); +struct miqt_string QWebSocket_resourceName(const QWebSocket* self); +QUrl* QWebSocket_requestUrl(const QWebSocket* self); +QNetworkRequest* QWebSocket_request(const QWebSocket* self); +struct miqt_string QWebSocket_origin(const QWebSocket* self); +int QWebSocket_closeCode(const QWebSocket* self); +struct miqt_string QWebSocket_closeReason(const QWebSocket* self); +long long QWebSocket_sendTextMessage(QWebSocket* self, struct miqt_string message); +long long QWebSocket_sendBinaryMessage(QWebSocket* self, struct miqt_string data); +void QWebSocket_ignoreSslErrors(QWebSocket* self, struct miqt_array /* of QSslError* */ errors); +void QWebSocket_setSslConfiguration(QWebSocket* self, QSslConfiguration* sslConfiguration); +QSslConfiguration* QWebSocket_sslConfiguration(const QWebSocket* self); +long long QWebSocket_bytesToWrite(const QWebSocket* self); +void QWebSocket_setMaxAllowedIncomingFrameSize(QWebSocket* self, unsigned long long maxAllowedIncomingFrameSize); +unsigned long long QWebSocket_maxAllowedIncomingFrameSize(const QWebSocket* self); +void QWebSocket_setMaxAllowedIncomingMessageSize(QWebSocket* self, unsigned long long maxAllowedIncomingMessageSize); +unsigned long long QWebSocket_maxAllowedIncomingMessageSize(const QWebSocket* self); +unsigned long long QWebSocket_maxIncomingMessageSize(); +unsigned long long QWebSocket_maxIncomingFrameSize(); +void QWebSocket_setOutgoingFrameSize(QWebSocket* self, unsigned long long outgoingFrameSize); +unsigned long long QWebSocket_outgoingFrameSize(const QWebSocket* self); +unsigned long long QWebSocket_maxOutgoingFrameSize(); +void QWebSocket_close(QWebSocket* self); +void QWebSocket_open(QWebSocket* self, QUrl* url); +void QWebSocket_openWithRequest(QWebSocket* self, QNetworkRequest* request); +void QWebSocket_ping(QWebSocket* self); +void QWebSocket_ignoreSslErrors2(QWebSocket* self); +void QWebSocket_aboutToClose(QWebSocket* self); +void QWebSocket_connect_aboutToClose(QWebSocket* self, intptr_t slot); +void QWebSocket_connected(QWebSocket* self); +void QWebSocket_connect_connected(QWebSocket* self, intptr_t slot); +void QWebSocket_disconnected(QWebSocket* self); +void QWebSocket_connect_disconnected(QWebSocket* self, intptr_t slot); +void QWebSocket_stateChanged(QWebSocket* self, int state); +void QWebSocket_connect_stateChanged(QWebSocket* self, intptr_t slot); +void QWebSocket_proxyAuthenticationRequired(QWebSocket* self, QNetworkProxy* proxy, QAuthenticator* pAuthenticator); +void QWebSocket_connect_proxyAuthenticationRequired(QWebSocket* self, intptr_t slot); +void QWebSocket_readChannelFinished(QWebSocket* self); +void QWebSocket_connect_readChannelFinished(QWebSocket* self, intptr_t slot); +void QWebSocket_textFrameReceived(QWebSocket* self, struct miqt_string frame, bool isLastFrame); +void QWebSocket_connect_textFrameReceived(QWebSocket* self, intptr_t slot); +void QWebSocket_binaryFrameReceived(QWebSocket* self, struct miqt_string frame, bool isLastFrame); +void QWebSocket_connect_binaryFrameReceived(QWebSocket* self, intptr_t slot); +void QWebSocket_textMessageReceived(QWebSocket* self, struct miqt_string message); +void QWebSocket_connect_textMessageReceived(QWebSocket* self, intptr_t slot); +void QWebSocket_binaryMessageReceived(QWebSocket* self, struct miqt_string message); +void QWebSocket_connect_binaryMessageReceived(QWebSocket* self, intptr_t slot); +void QWebSocket_errorWithError(QWebSocket* self, int error); +void QWebSocket_connect_errorWithError(QWebSocket* self, intptr_t slot); +void QWebSocket_pong(QWebSocket* self, unsigned long long elapsedTime, struct miqt_string payload); +void QWebSocket_connect_pong(QWebSocket* self, intptr_t slot); +void QWebSocket_bytesWritten(QWebSocket* self, long long bytes); +void QWebSocket_connect_bytesWritten(QWebSocket* self, intptr_t slot); +void QWebSocket_sslErrors(QWebSocket* self, struct miqt_array /* of QSslError* */ errors); +void QWebSocket_connect_sslErrors(QWebSocket* self, intptr_t slot); +void QWebSocket_preSharedKeyAuthenticationRequired(QWebSocket* self, QSslPreSharedKeyAuthenticator* authenticator); +void QWebSocket_connect_preSharedKeyAuthenticationRequired(QWebSocket* self, intptr_t slot); +struct miqt_string QWebSocket_tr2(const char* s, const char* c); +struct miqt_string QWebSocket_tr3(const char* s, const char* c, int n); +struct miqt_string QWebSocket_trUtf82(const char* s, const char* c); +struct miqt_string QWebSocket_trUtf83(const char* s, const char* c, int n); +void QWebSocket_closeWithCloseCode(QWebSocket* self, int closeCode); +void QWebSocket_close2(QWebSocket* self, int closeCode, struct miqt_string reason); +void QWebSocket_pingWithPayload(QWebSocket* self, struct miqt_string payload); + +bool QWebSocket_override_virtual_event(void* self, intptr_t slot); +bool QWebSocket_virtualbase_event(void* self, QEvent* event); +bool QWebSocket_override_virtual_eventFilter(void* self, intptr_t slot); +bool QWebSocket_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QWebSocket_override_virtual_timerEvent(void* self, intptr_t slot); +void QWebSocket_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QWebSocket_override_virtual_childEvent(void* self, intptr_t slot); +void QWebSocket_virtualbase_childEvent(void* self, QChildEvent* event); +bool QWebSocket_override_virtual_customEvent(void* self, intptr_t slot); +void QWebSocket_virtualbase_customEvent(void* self, QEvent* event); +bool QWebSocket_override_virtual_connectNotify(void* self, intptr_t slot); +void QWebSocket_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QWebSocket_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QWebSocket_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QWebSocket_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QWebSocket_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QWebSocket_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QWebSocket_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QWebSocket_delete(QWebSocket* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/websockets/gen_qwebsocketcorsauthenticator.cpp b/qt/websockets/gen_qwebsocketcorsauthenticator.cpp new file mode 100644 index 000000000..7d22e9db7 --- /dev/null +++ b/qt/websockets/gen_qwebsocketcorsauthenticator.cpp @@ -0,0 +1,55 @@ +#include +#include +#include +#include +#include +#include "gen_qwebsocketcorsauthenticator.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +QWebSocketCorsAuthenticator* QWebSocketCorsAuthenticator_new(struct miqt_string origin) { + QString origin_QString = QString::fromUtf8(origin.data, origin.len); + return new (std::nothrow) QWebSocketCorsAuthenticator(origin_QString); +} + +QWebSocketCorsAuthenticator* QWebSocketCorsAuthenticator_new2(QWebSocketCorsAuthenticator* other) { + return new (std::nothrow) QWebSocketCorsAuthenticator(*other); +} + +void QWebSocketCorsAuthenticator_swap(QWebSocketCorsAuthenticator* self, QWebSocketCorsAuthenticator* other) { + self->swap(*other); +} + +void QWebSocketCorsAuthenticator_operatorAssign(QWebSocketCorsAuthenticator* self, QWebSocketCorsAuthenticator* other) { + self->operator=(*other); +} + +struct miqt_string QWebSocketCorsAuthenticator_origin(const QWebSocketCorsAuthenticator* self) { + QString _ret = self->origin(); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +void QWebSocketCorsAuthenticator_setAllowed(QWebSocketCorsAuthenticator* self, bool allowed) { + self->setAllowed(allowed); +} + +bool QWebSocketCorsAuthenticator_allowed(const QWebSocketCorsAuthenticator* self) { + return self->allowed(); +} + +void QWebSocketCorsAuthenticator_delete(QWebSocketCorsAuthenticator* self) { + delete self; +} + diff --git a/qt/websockets/gen_qwebsocketcorsauthenticator.go b/qt/websockets/gen_qwebsocketcorsauthenticator.go new file mode 100644 index 000000000..f5760fb0d --- /dev/null +++ b/qt/websockets/gen_qwebsocketcorsauthenticator.go @@ -0,0 +1,99 @@ +package websockets + +/* + +#include "gen_qwebsocketcorsauthenticator.h" +#include + +*/ +import "C" + +import ( + "runtime" + "unsafe" +) + +type QWebSocketCorsAuthenticator struct { + h *C.QWebSocketCorsAuthenticator +} + +func (this *QWebSocketCorsAuthenticator) cPointer() *C.QWebSocketCorsAuthenticator { + if this == nil { + return nil + } + return this.h +} + +func (this *QWebSocketCorsAuthenticator) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQWebSocketCorsAuthenticator constructs the type using only CGO pointers. +func newQWebSocketCorsAuthenticator(h *C.QWebSocketCorsAuthenticator) *QWebSocketCorsAuthenticator { + if h == nil { + return nil + } + + return &QWebSocketCorsAuthenticator{h: h} +} + +// UnsafeNewQWebSocketCorsAuthenticator constructs the type using only unsafe pointers. +func UnsafeNewQWebSocketCorsAuthenticator(h unsafe.Pointer) *QWebSocketCorsAuthenticator { + return newQWebSocketCorsAuthenticator((*C.QWebSocketCorsAuthenticator)(h)) +} + +// NewQWebSocketCorsAuthenticator constructs a new QWebSocketCorsAuthenticator object. +func NewQWebSocketCorsAuthenticator(origin string) *QWebSocketCorsAuthenticator { + origin_ms := C.struct_miqt_string{} + origin_ms.data = C.CString(origin) + origin_ms.len = C.size_t(len(origin)) + defer C.free(unsafe.Pointer(origin_ms.data)) + + return newQWebSocketCorsAuthenticator(C.QWebSocketCorsAuthenticator_new(origin_ms)) +} + +// NewQWebSocketCorsAuthenticator2 constructs a new QWebSocketCorsAuthenticator object. +func NewQWebSocketCorsAuthenticator2(other *QWebSocketCorsAuthenticator) *QWebSocketCorsAuthenticator { + + return newQWebSocketCorsAuthenticator(C.QWebSocketCorsAuthenticator_new2(other.cPointer())) +} + +func (this *QWebSocketCorsAuthenticator) Swap(other *QWebSocketCorsAuthenticator) { + C.QWebSocketCorsAuthenticator_swap(this.h, other.cPointer()) +} + +func (this *QWebSocketCorsAuthenticator) OperatorAssign(other *QWebSocketCorsAuthenticator) { + C.QWebSocketCorsAuthenticator_operatorAssign(this.h, other.cPointer()) +} + +func (this *QWebSocketCorsAuthenticator) Origin() string { + var _ms C.struct_miqt_string = C.QWebSocketCorsAuthenticator_origin(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocketCorsAuthenticator) SetAllowed(allowed bool) { + C.QWebSocketCorsAuthenticator_setAllowed(this.h, (C.bool)(allowed)) +} + +func (this *QWebSocketCorsAuthenticator) Allowed() bool { + return (bool)(C.QWebSocketCorsAuthenticator_allowed(this.h)) +} + +// Delete this object from C++ memory. +func (this *QWebSocketCorsAuthenticator) Delete() { + C.QWebSocketCorsAuthenticator_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 *QWebSocketCorsAuthenticator) GoGC() { + runtime.SetFinalizer(this, func(this *QWebSocketCorsAuthenticator) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/websockets/gen_qwebsocketcorsauthenticator.h b/qt/websockets/gen_qwebsocketcorsauthenticator.h new file mode 100644 index 000000000..d177f3243 --- /dev/null +++ b/qt/websockets/gen_qwebsocketcorsauthenticator.h @@ -0,0 +1,37 @@ +#pragma once +#ifndef MIQT_QT_WEBSOCKETS_GEN_QWEBSOCKETCORSAUTHENTICATOR_H +#define MIQT_QT_WEBSOCKETS_GEN_QWEBSOCKETCORSAUTHENTICATOR_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QWebSocketCorsAuthenticator; +#else +typedef struct QWebSocketCorsAuthenticator QWebSocketCorsAuthenticator; +#endif + +QWebSocketCorsAuthenticator* QWebSocketCorsAuthenticator_new(struct miqt_string origin); +QWebSocketCorsAuthenticator* QWebSocketCorsAuthenticator_new2(QWebSocketCorsAuthenticator* other); +void QWebSocketCorsAuthenticator_swap(QWebSocketCorsAuthenticator* self, QWebSocketCorsAuthenticator* other); +void QWebSocketCorsAuthenticator_operatorAssign(QWebSocketCorsAuthenticator* self, QWebSocketCorsAuthenticator* other); +struct miqt_string QWebSocketCorsAuthenticator_origin(const QWebSocketCorsAuthenticator* self); +void QWebSocketCorsAuthenticator_setAllowed(QWebSocketCorsAuthenticator* self, bool allowed); +bool QWebSocketCorsAuthenticator_allowed(const QWebSocketCorsAuthenticator* self); + +void QWebSocketCorsAuthenticator_delete(QWebSocketCorsAuthenticator* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/websockets/gen_qwebsocketprotocol.cpp b/qt/websockets/gen_qwebsocketprotocol.cpp new file mode 100644 index 000000000..d3701f82f --- /dev/null +++ b/qt/websockets/gen_qwebsocketprotocol.cpp @@ -0,0 +1,11 @@ +#include +#include "gen_qwebsocketprotocol.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + diff --git a/qt/websockets/gen_qwebsocketprotocol.go b/qt/websockets/gen_qwebsocketprotocol.go new file mode 100644 index 000000000..d48015183 --- /dev/null +++ b/qt/websockets/gen_qwebsocketprotocol.go @@ -0,0 +1,41 @@ +package websockets + +/* + +#include "gen_qwebsocketprotocol.h" +#include + +*/ +import "C" + +type QWebSocketProtocol__Version int + +const ( + QWebSocketProtocol__VersionUnknown QWebSocketProtocol__Version = -1 + QWebSocketProtocol__Version0 QWebSocketProtocol__Version = 0 + QWebSocketProtocol__Version4 QWebSocketProtocol__Version = 4 + QWebSocketProtocol__Version5 QWebSocketProtocol__Version = 5 + QWebSocketProtocol__Version6 QWebSocketProtocol__Version = 6 + QWebSocketProtocol__Version7 QWebSocketProtocol__Version = 7 + QWebSocketProtocol__Version8 QWebSocketProtocol__Version = 8 + QWebSocketProtocol__Version13 QWebSocketProtocol__Version = 13 + QWebSocketProtocol__VersionLatest QWebSocketProtocol__Version = 13 +) + +type QWebSocketProtocol__CloseCode int + +const ( + QWebSocketProtocol__CloseCodeNormal QWebSocketProtocol__CloseCode = 1000 + QWebSocketProtocol__CloseCodeGoingAway QWebSocketProtocol__CloseCode = 1001 + QWebSocketProtocol__CloseCodeProtocolError QWebSocketProtocol__CloseCode = 1002 + QWebSocketProtocol__CloseCodeDatatypeNotSupported QWebSocketProtocol__CloseCode = 1003 + QWebSocketProtocol__CloseCodeReserved1004 QWebSocketProtocol__CloseCode = 1004 + QWebSocketProtocol__CloseCodeMissingStatusCode QWebSocketProtocol__CloseCode = 1005 + QWebSocketProtocol__CloseCodeAbnormalDisconnection QWebSocketProtocol__CloseCode = 1006 + QWebSocketProtocol__CloseCodeWrongDatatype QWebSocketProtocol__CloseCode = 1007 + QWebSocketProtocol__CloseCodePolicyViolated QWebSocketProtocol__CloseCode = 1008 + QWebSocketProtocol__CloseCodeTooMuchData QWebSocketProtocol__CloseCode = 1009 + QWebSocketProtocol__CloseCodeMissingExtension QWebSocketProtocol__CloseCode = 1010 + QWebSocketProtocol__CloseCodeBadOperation QWebSocketProtocol__CloseCode = 1011 + QWebSocketProtocol__CloseCodeTlsHandshakeFailed QWebSocketProtocol__CloseCode = 1015 +) diff --git a/qt/websockets/gen_qwebsocketprotocol.h b/qt/websockets/gen_qwebsocketprotocol.h new file mode 100644 index 000000000..437bd559a --- /dev/null +++ b/qt/websockets/gen_qwebsocketprotocol.h @@ -0,0 +1,25 @@ +#pragma once +#ifndef MIQT_QT_WEBSOCKETS_GEN_QWEBSOCKETPROTOCOL_H +#define MIQT_QT_WEBSOCKETS_GEN_QWEBSOCKETPROTOCOL_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +#else +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt/websockets/gen_qwebsocketserver.cpp b/qt/websockets/gen_qwebsocketserver.cpp new file mode 100644 index 000000000..54dcfed24 --- /dev/null +++ b/qt/websockets/gen_qwebsocketserver.cpp @@ -0,0 +1,705 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qwebsocketserver.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QWebSocketServer_acceptError(intptr_t, int); +void miqt_exec_callback_QWebSocketServer_serverError(intptr_t, int); +void miqt_exec_callback_QWebSocketServer_originAuthenticationRequired(intptr_t, QWebSocketCorsAuthenticator*); +void miqt_exec_callback_QWebSocketServer_newConnection(intptr_t); +void miqt_exec_callback_QWebSocketServer_peerVerifyError(intptr_t, QSslError*); +void miqt_exec_callback_QWebSocketServer_sslErrors(intptr_t, struct miqt_array /* of QSslError* */ ); +void miqt_exec_callback_QWebSocketServer_preSharedKeyAuthenticationRequired(intptr_t, QSslPreSharedKeyAuthenticator*); +void miqt_exec_callback_QWebSocketServer_closed(intptr_t); +QWebSocket* miqt_exec_callback_QWebSocketServer_nextPendingConnection(QWebSocketServer*, intptr_t); +bool miqt_exec_callback_QWebSocketServer_event(QWebSocketServer*, intptr_t, QEvent*); +bool miqt_exec_callback_QWebSocketServer_eventFilter(QWebSocketServer*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QWebSocketServer_timerEvent(QWebSocketServer*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QWebSocketServer_childEvent(QWebSocketServer*, intptr_t, QChildEvent*); +void miqt_exec_callback_QWebSocketServer_customEvent(QWebSocketServer*, intptr_t, QEvent*); +void miqt_exec_callback_QWebSocketServer_connectNotify(QWebSocketServer*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QWebSocketServer_disconnectNotify(QWebSocketServer*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQWebSocketServer final : public QWebSocketServer { +public: + + MiqtVirtualQWebSocketServer(const QString& serverName, QWebSocketServer::SslMode secureMode): QWebSocketServer(serverName, secureMode) {} + MiqtVirtualQWebSocketServer(const QString& serverName, QWebSocketServer::SslMode secureMode, QObject* parent): QWebSocketServer(serverName, secureMode, parent) {} + + virtual ~MiqtVirtualQWebSocketServer() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__nextPendingConnection = 0; + + // Subclass to allow providing a Go implementation + virtual QWebSocket* nextPendingConnection() override { + if (handle__nextPendingConnection == 0) { + return QWebSocketServer::nextPendingConnection(); + } + + QWebSocket* callback_return_value = miqt_exec_callback_QWebSocketServer_nextPendingConnection(this, handle__nextPendingConnection); + return callback_return_value; + } + + friend QWebSocket* QWebSocketServer_virtualbase_nextPendingConnection(void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QWebSocketServer::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QWebSocketServer_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QWebSocketServer_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QWebSocketServer::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QWebSocketServer_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QWebSocketServer_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) { + QWebSocketServer::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QWebSocketServer_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QWebSocketServer_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) { + QWebSocketServer::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QWebSocketServer_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QWebSocketServer_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) { + QWebSocketServer::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QWebSocketServer_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QWebSocketServer_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) { + QWebSocketServer::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QWebSocketServer_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QWebSocketServer_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) { + QWebSocketServer::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QWebSocketServer_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QWebSocketServer_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QWebSocketServer_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QWebSocketServer_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QWebSocketServer_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QWebSocketServer_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QWebSocketServer* QWebSocketServer_new(struct miqt_string serverName, int secureMode) { + QString serverName_QString = QString::fromUtf8(serverName.data, serverName.len); + return new (std::nothrow) MiqtVirtualQWebSocketServer(serverName_QString, static_cast(secureMode)); +} + +QWebSocketServer* QWebSocketServer_new2(struct miqt_string serverName, int secureMode, QObject* parent) { + QString serverName_QString = QString::fromUtf8(serverName.data, serverName.len); + return new (std::nothrow) MiqtVirtualQWebSocketServer(serverName_QString, static_cast(secureMode), parent); +} + +void QWebSocketServer_virtbase(QWebSocketServer* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QWebSocketServer_metaObject(const QWebSocketServer* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QWebSocketServer_metacast(QWebSocketServer* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QWebSocketServer_tr(const char* s) { + QString _ret = QWebSocketServer::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 QWebSocketServer_trUtf8(const char* s) { + QString _ret = QWebSocketServer::trUtf8(s); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +bool QWebSocketServer_listen(QWebSocketServer* self) { + return self->listen(); +} + +void QWebSocketServer_close(QWebSocketServer* self) { + self->close(); +} + +bool QWebSocketServer_isListening(const QWebSocketServer* self) { + return self->isListening(); +} + +void QWebSocketServer_setMaxPendingConnections(QWebSocketServer* self, int numConnections) { + self->setMaxPendingConnections(static_cast(numConnections)); +} + +int QWebSocketServer_maxPendingConnections(const QWebSocketServer* self) { + return self->maxPendingConnections(); +} + +void QWebSocketServer_setHandshakeTimeoutWithMsec(QWebSocketServer* self, int msec) { + self->setHandshakeTimeout(static_cast(msec)); +} + +int QWebSocketServer_handshakeTimeoutMS(const QWebSocketServer* self) { + return self->handshakeTimeoutMS(); +} + +unsigned short QWebSocketServer_serverPort(const QWebSocketServer* self) { + quint16 _ret = self->serverPort(); + return static_cast(_ret); +} + +QHostAddress* QWebSocketServer_serverAddress(const QWebSocketServer* self) { + return new QHostAddress(self->serverAddress()); +} + +QUrl* QWebSocketServer_serverUrl(const QWebSocketServer* self) { + return new QUrl(self->serverUrl()); +} + +int QWebSocketServer_secureMode(const QWebSocketServer* self) { + QWebSocketServer::SslMode _ret = self->secureMode(); + return static_cast(_ret); +} + +bool QWebSocketServer_setSocketDescriptor(QWebSocketServer* self, int socketDescriptor) { + return self->setSocketDescriptor(static_cast(socketDescriptor)); +} + +int QWebSocketServer_socketDescriptor(const QWebSocketServer* self) { + return self->socketDescriptor(); +} + +bool QWebSocketServer_setNativeDescriptor(QWebSocketServer* self, intptr_t descriptor) { + return self->setNativeDescriptor((qintptr)(descriptor)); +} + +intptr_t QWebSocketServer_nativeDescriptor(const QWebSocketServer* self) { + qintptr _ret = self->nativeDescriptor(); + return (intptr_t)(_ret); +} + +bool QWebSocketServer_hasPendingConnections(const QWebSocketServer* self) { + return self->hasPendingConnections(); +} + +QWebSocket* QWebSocketServer_nextPendingConnection(QWebSocketServer* self) { + return self->nextPendingConnection(); +} + +int QWebSocketServer_error(const QWebSocketServer* self) { + QWebSocketProtocol::CloseCode _ret = self->error(); + return static_cast(_ret); +} + +struct miqt_string QWebSocketServer_errorString(const QWebSocketServer* 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 QWebSocketServer_pauseAccepting(QWebSocketServer* self) { + self->pauseAccepting(); +} + +void QWebSocketServer_resumeAccepting(QWebSocketServer* self) { + self->resumeAccepting(); +} + +void QWebSocketServer_setServerName(QWebSocketServer* self, struct miqt_string serverName) { + QString serverName_QString = QString::fromUtf8(serverName.data, serverName.len); + self->setServerName(serverName_QString); +} + +struct miqt_string QWebSocketServer_serverName(const QWebSocketServer* self) { + QString _ret = self->serverName(); + // 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 QWebSocketServer_setProxy(QWebSocketServer* self, QNetworkProxy* networkProxy) { + self->setProxy(*networkProxy); +} + +QNetworkProxy* QWebSocketServer_proxy(const QWebSocketServer* self) { + return new QNetworkProxy(self->proxy()); +} + +void QWebSocketServer_setSslConfiguration(QWebSocketServer* self, QSslConfiguration* sslConfiguration) { + self->setSslConfiguration(*sslConfiguration); +} + +QSslConfiguration* QWebSocketServer_sslConfiguration(const QWebSocketServer* self) { + return new QSslConfiguration(self->sslConfiguration()); +} + +struct miqt_array /* of int */ QWebSocketServer_supportedVersions(const QWebSocketServer* self) { + QList _ret = self->supportedVersions(); + // Convert QList<> from C++ memory to manually-managed C memory + int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebSocketProtocol::Version _lv_ret = _ret[i]; + _arr[i] = static_cast(_lv_ret); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +void QWebSocketServer_handleConnection(const QWebSocketServer* self, QTcpSocket* socket) { + self->handleConnection(socket); +} + +void QWebSocketServer_acceptError(QWebSocketServer* self, int socketError) { + self->acceptError(static_cast(socketError)); +} + +void QWebSocketServer_connect_acceptError(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::acceptError), self, [=](QAbstractSocket::SocketError socketError) { + QAbstractSocket::SocketError socketError_ret = socketError; + int sigval1 = static_cast(socketError_ret); + miqt_exec_callback_QWebSocketServer_acceptError(slot, sigval1); + }); +} + +void QWebSocketServer_serverError(QWebSocketServer* self, int closeCode) { + self->serverError(static_cast(closeCode)); +} + +void QWebSocketServer_connect_serverError(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::serverError), self, [=](QWebSocketProtocol::CloseCode closeCode) { + QWebSocketProtocol::CloseCode closeCode_ret = closeCode; + int sigval1 = static_cast(closeCode_ret); + miqt_exec_callback_QWebSocketServer_serverError(slot, sigval1); + }); +} + +void QWebSocketServer_originAuthenticationRequired(QWebSocketServer* self, QWebSocketCorsAuthenticator* pAuthenticator) { + self->originAuthenticationRequired(pAuthenticator); +} + +void QWebSocketServer_connect_originAuthenticationRequired(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::originAuthenticationRequired), self, [=](QWebSocketCorsAuthenticator* pAuthenticator) { + QWebSocketCorsAuthenticator* sigval1 = pAuthenticator; + miqt_exec_callback_QWebSocketServer_originAuthenticationRequired(slot, sigval1); + }); +} + +void QWebSocketServer_newConnection(QWebSocketServer* self) { + self->newConnection(); +} + +void QWebSocketServer_connect_newConnection(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::newConnection), self, [=]() { + miqt_exec_callback_QWebSocketServer_newConnection(slot); + }); +} + +void QWebSocketServer_peerVerifyError(QWebSocketServer* self, QSslError* error) { + self->peerVerifyError(*error); +} + +void QWebSocketServer_connect_peerVerifyError(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::peerVerifyError), self, [=](const QSslError& error) { + const QSslError& error_ret = error; + // Cast returned reference into pointer + QSslError* sigval1 = const_cast(&error_ret); + miqt_exec_callback_QWebSocketServer_peerVerifyError(slot, sigval1); + }); +} + +void QWebSocketServer_sslErrors(QWebSocketServer* self, struct miqt_array /* of QSslError* */ errors) { + QList errors_QList; + errors_QList.reserve(errors.len); + QSslError** errors_arr = static_cast(errors.data); + for(size_t i = 0; i < errors.len; ++i) { + errors_QList.push_back(*(errors_arr[i])); + } + self->sslErrors(errors_QList); +} + +void QWebSocketServer_connect_sslErrors(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast&)>(&QWebSocketServer::sslErrors), self, [=](const QList& errors) { + const QList& errors_ret = errors; + // Convert QList<> from C++ memory to manually-managed C memory + QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.length())); + for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { + errors_arr[i] = new QSslError(errors_ret[i]); + } + struct miqt_array errors_out; + errors_out.len = errors_ret.length(); + errors_out.data = static_cast(errors_arr); + struct miqt_array /* of QSslError* */ sigval1 = errors_out; + miqt_exec_callback_QWebSocketServer_sslErrors(slot, sigval1); + }); +} + +void QWebSocketServer_preSharedKeyAuthenticationRequired(QWebSocketServer* self, QSslPreSharedKeyAuthenticator* authenticator) { + self->preSharedKeyAuthenticationRequired(authenticator); +} + +void QWebSocketServer_connect_preSharedKeyAuthenticationRequired(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::preSharedKeyAuthenticationRequired), self, [=](QSslPreSharedKeyAuthenticator* authenticator) { + QSslPreSharedKeyAuthenticator* sigval1 = authenticator; + miqt_exec_callback_QWebSocketServer_preSharedKeyAuthenticationRequired(slot, sigval1); + }); +} + +void QWebSocketServer_closed(QWebSocketServer* self) { + self->closed(); +} + +void QWebSocketServer_connect_closed(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::closed), self, [=]() { + miqt_exec_callback_QWebSocketServer_closed(slot); + }); +} + +struct miqt_string QWebSocketServer_tr2(const char* s, const char* c) { + QString _ret = QWebSocketServer::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 QWebSocketServer_tr3(const char* s, const char* c, int n) { + QString _ret = QWebSocketServer::tr(s, c, static_cast(n)); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string QWebSocketServer_trUtf82(const char* s, const char* c) { + QString _ret = QWebSocketServer::trUtf8(s, c); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string QWebSocketServer_trUtf83(const char* s, const char* c, int n) { + QString _ret = QWebSocketServer::trUtf8(s, c, static_cast(n)); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +bool QWebSocketServer_listenWithAddress(QWebSocketServer* self, QHostAddress* address) { + return self->listen(*address); +} + +bool QWebSocketServer_listen2(QWebSocketServer* self, QHostAddress* address, unsigned short port) { + return self->listen(*address, static_cast(port)); +} + +bool QWebSocketServer_override_virtual_nextPendingConnection(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__nextPendingConnection = slot; + return true; +} + +QWebSocket* QWebSocketServer_virtualbase_nextPendingConnection(void* self) { + return static_cast(self)->QWebSocketServer::nextPendingConnection(); +} + +bool QWebSocketServer_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QWebSocketServer_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QWebSocketServer::event(event); +} + +bool QWebSocketServer_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QWebSocketServer_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QWebSocketServer::eventFilter(watched, event); +} + +bool QWebSocketServer_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QWebSocketServer_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QWebSocketServer::timerEvent(event); +} + +bool QWebSocketServer_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QWebSocketServer_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QWebSocketServer::childEvent(event); +} + +bool QWebSocketServer_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QWebSocketServer_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QWebSocketServer::customEvent(event); +} + +bool QWebSocketServer_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QWebSocketServer_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QWebSocketServer::connectNotify(*signal); +} + +bool QWebSocketServer_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QWebSocketServer_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QWebSocketServer::disconnectNotify(*signal); +} + +QObject* QWebSocketServer_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QWebSocketServer_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QWebSocketServer_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QWebSocketServer_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QWebSocketServer_delete(QWebSocketServer* self) { + delete self; +} + diff --git a/qt/websockets/gen_qwebsocketserver.go b/qt/websockets/gen_qwebsocketserver.go new file mode 100644 index 000000000..cf3dbf96e --- /dev/null +++ b/qt/websockets/gen_qwebsocketserver.go @@ -0,0 +1,753 @@ +package websockets + +/* + +#include "gen_qwebsocketserver.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt" + "github.com/mappu/miqt/qt/network" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QWebSocketServer__SslMode int + +const ( + QWebSocketServer__SecureMode QWebSocketServer__SslMode = 0 + QWebSocketServer__NonSecureMode QWebSocketServer__SslMode = 1 +) + +type QWebSocketServer struct { + h *C.QWebSocketServer + *qt.QObject +} + +func (this *QWebSocketServer) cPointer() *C.QWebSocketServer { + if this == nil { + return nil + } + return this.h +} + +func (this *QWebSocketServer) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQWebSocketServer constructs the type using only CGO pointers. +func newQWebSocketServer(h *C.QWebSocketServer) *QWebSocketServer { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QWebSocketServer_virtbase(h, &outptr_QObject) + + return &QWebSocketServer{h: h, + QObject: qt.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQWebSocketServer constructs the type using only unsafe pointers. +func UnsafeNewQWebSocketServer(h unsafe.Pointer) *QWebSocketServer { + return newQWebSocketServer((*C.QWebSocketServer)(h)) +} + +// NewQWebSocketServer constructs a new QWebSocketServer object. +func NewQWebSocketServer(serverName string, secureMode QWebSocketServer__SslMode) *QWebSocketServer { + serverName_ms := C.struct_miqt_string{} + serverName_ms.data = C.CString(serverName) + serverName_ms.len = C.size_t(len(serverName)) + defer C.free(unsafe.Pointer(serverName_ms.data)) + + return newQWebSocketServer(C.QWebSocketServer_new(serverName_ms, (C.int)(secureMode))) +} + +// NewQWebSocketServer2 constructs a new QWebSocketServer object. +func NewQWebSocketServer2(serverName string, secureMode QWebSocketServer__SslMode, parent *qt.QObject) *QWebSocketServer { + serverName_ms := C.struct_miqt_string{} + serverName_ms.data = C.CString(serverName) + serverName_ms.len = C.size_t(len(serverName)) + defer C.free(unsafe.Pointer(serverName_ms.data)) + + return newQWebSocketServer(C.QWebSocketServer_new2(serverName_ms, (C.int)(secureMode), (*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QWebSocketServer) MetaObject() *qt.QMetaObject { + return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QWebSocketServer_metaObject(this.h))) +} + +func (this *QWebSocketServer) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QWebSocketServer_metacast(this.h, param1_Cstring)) +} + +func QWebSocketServer_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QWebSocketServer_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QWebSocketServer_TrUtf8(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QWebSocketServer_trUtf8(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocketServer) Listen() bool { + return (bool)(C.QWebSocketServer_listen(this.h)) +} + +func (this *QWebSocketServer) Close() { + C.QWebSocketServer_close(this.h) +} + +func (this *QWebSocketServer) IsListening() bool { + return (bool)(C.QWebSocketServer_isListening(this.h)) +} + +func (this *QWebSocketServer) SetMaxPendingConnections(numConnections int) { + C.QWebSocketServer_setMaxPendingConnections(this.h, (C.int)(numConnections)) +} + +func (this *QWebSocketServer) MaxPendingConnections() int { + return (int)(C.QWebSocketServer_maxPendingConnections(this.h)) +} + +func (this *QWebSocketServer) SetHandshakeTimeoutWithMsec(msec int) { + C.QWebSocketServer_setHandshakeTimeoutWithMsec(this.h, (C.int)(msec)) +} + +func (this *QWebSocketServer) HandshakeTimeoutMS() int { + return (int)(C.QWebSocketServer_handshakeTimeoutMS(this.h)) +} + +func (this *QWebSocketServer) ServerPort() uint16 { + return (uint16)(C.QWebSocketServer_serverPort(this.h)) +} + +func (this *QWebSocketServer) ServerAddress() *network.QHostAddress { + _goptr := network.UnsafeNewQHostAddress(unsafe.Pointer(C.QWebSocketServer_serverAddress(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocketServer) ServerUrl() *qt.QUrl { + _goptr := qt.UnsafeNewQUrl(unsafe.Pointer(C.QWebSocketServer_serverUrl(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocketServer) SecureMode() QWebSocketServer__SslMode { + return (QWebSocketServer__SslMode)(C.QWebSocketServer_secureMode(this.h)) +} + +func (this *QWebSocketServer) SetSocketDescriptor(socketDescriptor int) bool { + return (bool)(C.QWebSocketServer_setSocketDescriptor(this.h, (C.int)(socketDescriptor))) +} + +func (this *QWebSocketServer) SocketDescriptor() int { + return (int)(C.QWebSocketServer_socketDescriptor(this.h)) +} + +func (this *QWebSocketServer) SetNativeDescriptor(descriptor uintptr) bool { + return (bool)(C.QWebSocketServer_setNativeDescriptor(this.h, (C.intptr_t)(descriptor))) +} + +func (this *QWebSocketServer) NativeDescriptor() uintptr { + return (uintptr)(C.QWebSocketServer_nativeDescriptor(this.h)) +} + +func (this *QWebSocketServer) HasPendingConnections() bool { + return (bool)(C.QWebSocketServer_hasPendingConnections(this.h)) +} + +func (this *QWebSocketServer) NextPendingConnection() *QWebSocket { + return newQWebSocket(C.QWebSocketServer_nextPendingConnection(this.h)) +} + +func (this *QWebSocketServer) Error() QWebSocketProtocol__CloseCode { + return (QWebSocketProtocol__CloseCode)(C.QWebSocketServer_error(this.h)) +} + +func (this *QWebSocketServer) ErrorString() string { + var _ms C.struct_miqt_string = C.QWebSocketServer_errorString(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocketServer) PauseAccepting() { + C.QWebSocketServer_pauseAccepting(this.h) +} + +func (this *QWebSocketServer) ResumeAccepting() { + C.QWebSocketServer_resumeAccepting(this.h) +} + +func (this *QWebSocketServer) SetServerName(serverName string) { + serverName_ms := C.struct_miqt_string{} + serverName_ms.data = C.CString(serverName) + serverName_ms.len = C.size_t(len(serverName)) + defer C.free(unsafe.Pointer(serverName_ms.data)) + C.QWebSocketServer_setServerName(this.h, serverName_ms) +} + +func (this *QWebSocketServer) ServerName() string { + var _ms C.struct_miqt_string = C.QWebSocketServer_serverName(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocketServer) SetProxy(networkProxy *network.QNetworkProxy) { + C.QWebSocketServer_setProxy(this.h, (*C.QNetworkProxy)(networkProxy.UnsafePointer())) +} + +func (this *QWebSocketServer) Proxy() *network.QNetworkProxy { + _goptr := network.UnsafeNewQNetworkProxy(unsafe.Pointer(C.QWebSocketServer_proxy(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocketServer) SetSslConfiguration(sslConfiguration *network.QSslConfiguration) { + C.QWebSocketServer_setSslConfiguration(this.h, (*C.QSslConfiguration)(sslConfiguration.UnsafePointer())) +} + +func (this *QWebSocketServer) SslConfiguration() *network.QSslConfiguration { + _goptr := network.UnsafeNewQSslConfiguration(unsafe.Pointer(C.QWebSocketServer_sslConfiguration(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocketServer) SupportedVersions() []QWebSocketProtocol__Version { + var _ma C.struct_miqt_array = C.QWebSocketServer_supportedVersions(this.h) + _ret := make([]QWebSocketProtocol__Version, int(_ma.len)) + _outCast := (*[0xffff]C.int)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _ret[i] = (QWebSocketProtocol__Version)(_outCast[i]) + } + return _ret +} + +func (this *QWebSocketServer) HandleConnection(socket *network.QTcpSocket) { + C.QWebSocketServer_handleConnection(this.h, (*C.QTcpSocket)(socket.UnsafePointer())) +} + +func (this *QWebSocketServer) AcceptError(socketError network.QAbstractSocket__SocketError) { + C.QWebSocketServer_acceptError(this.h, (C.int)(socketError)) +} +func (this *QWebSocketServer) OnAcceptError(slot func(socketError network.QAbstractSocket__SocketError)) { + C.QWebSocketServer_connect_acceptError(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_acceptError +func miqt_exec_callback_QWebSocketServer_acceptError(cb C.intptr_t, socketError C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(socketError network.QAbstractSocket__SocketError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (network.QAbstractSocket__SocketError)(socketError) + + gofunc(slotval1) +} + +func (this *QWebSocketServer) ServerError(closeCode QWebSocketProtocol__CloseCode) { + C.QWebSocketServer_serverError(this.h, (C.int)(closeCode)) +} +func (this *QWebSocketServer) OnServerError(slot func(closeCode QWebSocketProtocol__CloseCode)) { + C.QWebSocketServer_connect_serverError(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_serverError +func miqt_exec_callback_QWebSocketServer_serverError(cb C.intptr_t, closeCode C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(closeCode QWebSocketProtocol__CloseCode)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (QWebSocketProtocol__CloseCode)(closeCode) + + gofunc(slotval1) +} + +func (this *QWebSocketServer) OriginAuthenticationRequired(pAuthenticator *QWebSocketCorsAuthenticator) { + C.QWebSocketServer_originAuthenticationRequired(this.h, pAuthenticator.cPointer()) +} +func (this *QWebSocketServer) OnOriginAuthenticationRequired(slot func(pAuthenticator *QWebSocketCorsAuthenticator)) { + C.QWebSocketServer_connect_originAuthenticationRequired(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_originAuthenticationRequired +func miqt_exec_callback_QWebSocketServer_originAuthenticationRequired(cb C.intptr_t, pAuthenticator *C.QWebSocketCorsAuthenticator) { + gofunc, ok := cgo.Handle(cb).Value().(func(pAuthenticator *QWebSocketCorsAuthenticator)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQWebSocketCorsAuthenticator(pAuthenticator) + + gofunc(slotval1) +} + +func (this *QWebSocketServer) NewConnection() { + C.QWebSocketServer_newConnection(this.h) +} +func (this *QWebSocketServer) OnNewConnection(slot func()) { + C.QWebSocketServer_connect_newConnection(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_newConnection +func miqt_exec_callback_QWebSocketServer_newConnection(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 *QWebSocketServer) PeerVerifyError(error *network.QSslError) { + C.QWebSocketServer_peerVerifyError(this.h, (*C.QSslError)(error.UnsafePointer())) +} +func (this *QWebSocketServer) OnPeerVerifyError(slot func(error *network.QSslError)) { + C.QWebSocketServer_connect_peerVerifyError(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_peerVerifyError +func miqt_exec_callback_QWebSocketServer_peerVerifyError(cb C.intptr_t, error *C.QSslError) { + gofunc, ok := cgo.Handle(cb).Value().(func(error *network.QSslError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := network.UnsafeNewQSslError(unsafe.Pointer(error)) + + gofunc(slotval1) +} + +func (this *QWebSocketServer) SslErrors(errors []network.QSslError) { + errors_CArray := (*[0xffff]*C.QSslError)(C.malloc(C.size_t(8 * len(errors)))) + defer C.free(unsafe.Pointer(errors_CArray)) + for i := range errors { + errors_CArray[i] = (*C.QSslError)(errors[i].UnsafePointer()) + } + errors_ma := C.struct_miqt_array{len: C.size_t(len(errors)), data: unsafe.Pointer(errors_CArray)} + C.QWebSocketServer_sslErrors(this.h, errors_ma) +} +func (this *QWebSocketServer) OnSslErrors(slot func(errors []network.QSslError)) { + C.QWebSocketServer_connect_sslErrors(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_sslErrors +func miqt_exec_callback_QWebSocketServer_sslErrors(cb C.intptr_t, errors C.struct_miqt_array) { + gofunc, ok := cgo.Handle(cb).Value().(func(errors []network.QSslError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var errors_ma C.struct_miqt_array = errors + errors_ret := make([]network.QSslError, int(errors_ma.len)) + errors_outCast := (*[0xffff]*C.QSslError)(unsafe.Pointer(errors_ma.data)) // hey ya + for i := 0; i < int(errors_ma.len); i++ { + errors_lv_goptr := network.UnsafeNewQSslError(unsafe.Pointer(errors_outCast[i])) + errors_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + errors_ret[i] = *errors_lv_goptr + } + slotval1 := errors_ret + + gofunc(slotval1) +} + +func (this *QWebSocketServer) PreSharedKeyAuthenticationRequired(authenticator *network.QSslPreSharedKeyAuthenticator) { + C.QWebSocketServer_preSharedKeyAuthenticationRequired(this.h, (*C.QSslPreSharedKeyAuthenticator)(authenticator.UnsafePointer())) +} +func (this *QWebSocketServer) OnPreSharedKeyAuthenticationRequired(slot func(authenticator *network.QSslPreSharedKeyAuthenticator)) { + C.QWebSocketServer_connect_preSharedKeyAuthenticationRequired(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_preSharedKeyAuthenticationRequired +func miqt_exec_callback_QWebSocketServer_preSharedKeyAuthenticationRequired(cb C.intptr_t, authenticator *C.QSslPreSharedKeyAuthenticator) { + gofunc, ok := cgo.Handle(cb).Value().(func(authenticator *network.QSslPreSharedKeyAuthenticator)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := network.UnsafeNewQSslPreSharedKeyAuthenticator(unsafe.Pointer(authenticator)) + + gofunc(slotval1) +} + +func (this *QWebSocketServer) Closed() { + C.QWebSocketServer_closed(this.h) +} +func (this *QWebSocketServer) OnClosed(slot func()) { + C.QWebSocketServer_connect_closed(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_closed +func miqt_exec_callback_QWebSocketServer_closed(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func QWebSocketServer_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.QWebSocketServer_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QWebSocketServer_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.QWebSocketServer_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 QWebSocketServer_TrUtf82(s string, c string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QWebSocketServer_trUtf82(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QWebSocketServer_TrUtf83(s string, c string, n int) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + c_Cstring := C.CString(c) + defer C.free(unsafe.Pointer(c_Cstring)) + var _ms C.struct_miqt_string = C.QWebSocketServer_trUtf83(s_Cstring, c_Cstring, (C.int)(n)) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocketServer) ListenWithAddress(address *network.QHostAddress) bool { + return (bool)(C.QWebSocketServer_listenWithAddress(this.h, (*C.QHostAddress)(address.UnsafePointer()))) +} + +func (this *QWebSocketServer) Listen2(address *network.QHostAddress, port uint16) bool { + return (bool)(C.QWebSocketServer_listen2(this.h, (*C.QHostAddress)(address.UnsafePointer()), (C.ushort)(port))) +} + +// Sender can only be called from a QWebSocketServer that was directly constructed. +func (this *QWebSocketServer) Sender() *qt.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt.UnsafeNewQObject(unsafe.Pointer(C.QWebSocketServer_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 QWebSocketServer that was directly constructed. +func (this *QWebSocketServer) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QWebSocketServer_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 QWebSocketServer that was directly constructed. +func (this *QWebSocketServer) 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.QWebSocketServer_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 QWebSocketServer that was directly constructed. +func (this *QWebSocketServer) IsSignalConnected(signal *qt.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QWebSocketServer_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 *QWebSocketServer) callVirtualBase_NextPendingConnection() *QWebSocket { + + return newQWebSocket(C.QWebSocketServer_virtualbase_nextPendingConnection(unsafe.Pointer(this.h))) + +} +func (this *QWebSocketServer) OnNextPendingConnection(slot func(super func() *QWebSocket) *QWebSocket) { + ok := C.QWebSocketServer_override_virtual_nextPendingConnection(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QWebSocketServer_nextPendingConnection +func miqt_exec_callback_QWebSocketServer_nextPendingConnection(self *C.QWebSocketServer, cb C.intptr_t) *C.QWebSocket { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QWebSocket) *QWebSocket) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QWebSocketServer{h: self}).callVirtualBase_NextPendingConnection) + + return virtualReturn.cPointer() + +} + +func (this *QWebSocketServer) callVirtualBase_Event(event *qt.QEvent) bool { + + return (bool)(C.QWebSocketServer_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QWebSocketServer) OnEvent(slot func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) { + ok := C.QWebSocketServer_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_QWebSocketServer_event +func miqt_exec_callback_QWebSocketServer_event(self *C.QWebSocketServer, cb C.intptr_t, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QWebSocketServer{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QWebSocketServer) callVirtualBase_EventFilter(watched *qt.QObject, event *qt.QEvent) bool { + + return (bool)(C.QWebSocketServer_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QWebSocketServer) OnEventFilter(slot func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) { + ok := C.QWebSocketServer_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_QWebSocketServer_eventFilter +func miqt_exec_callback_QWebSocketServer_eventFilter(self *C.QWebSocketServer, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(watched)) + + slotval2 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + virtualReturn := gofunc((&QWebSocketServer{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QWebSocketServer) callVirtualBase_TimerEvent(event *qt.QTimerEvent) { + + C.QWebSocketServer_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QWebSocketServer) OnTimerEvent(slot func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) { + ok := C.QWebSocketServer_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_QWebSocketServer_timerEvent +func miqt_exec_callback_QWebSocketServer_timerEvent(self *C.QWebSocketServer, cb C.intptr_t, event *C.QTimerEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQTimerEvent(unsafe.Pointer(event)) + + gofunc((&QWebSocketServer{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QWebSocketServer) callVirtualBase_ChildEvent(event *qt.QChildEvent) { + + C.QWebSocketServer_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QWebSocketServer) OnChildEvent(slot func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) { + ok := C.QWebSocketServer_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_QWebSocketServer_childEvent +func miqt_exec_callback_QWebSocketServer_childEvent(self *C.QWebSocketServer, cb C.intptr_t, event *C.QChildEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQChildEvent(unsafe.Pointer(event)) + + gofunc((&QWebSocketServer{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QWebSocketServer) callVirtualBase_CustomEvent(event *qt.QEvent) { + + C.QWebSocketServer_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QWebSocketServer) OnCustomEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) { + ok := C.QWebSocketServer_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_QWebSocketServer_customEvent +func miqt_exec_callback_QWebSocketServer_customEvent(self *C.QWebSocketServer, cb C.intptr_t, event *C.QEvent) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event)) + + gofunc((&QWebSocketServer{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QWebSocketServer) callVirtualBase_ConnectNotify(signal *qt.QMetaMethod) { + + C.QWebSocketServer_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QWebSocketServer) OnConnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QWebSocketServer_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_QWebSocketServer_connectNotify +func miqt_exec_callback_QWebSocketServer_connectNotify(self *C.QWebSocketServer, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QWebSocketServer{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QWebSocketServer) callVirtualBase_DisconnectNotify(signal *qt.QMetaMethod) { + + C.QWebSocketServer_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QWebSocketServer) OnDisconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) { + ok := C.QWebSocketServer_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_QWebSocketServer_disconnectNotify +func miqt_exec_callback_QWebSocketServer_disconnectNotify(self *C.QWebSocketServer, cb C.intptr_t, signal *C.QMetaMethod) { + gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal)) + + gofunc((&QWebSocketServer{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QWebSocketServer) Delete() { + C.QWebSocketServer_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 *QWebSocketServer) GoGC() { + runtime.SetFinalizer(this, func(this *QWebSocketServer) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt/websockets/gen_qwebsocketserver.h b/qt/websockets/gen_qwebsocketserver.h new file mode 100644 index 000000000..a3d624ff5 --- /dev/null +++ b/qt/websockets/gen_qwebsocketserver.h @@ -0,0 +1,140 @@ +#pragma once +#ifndef MIQT_QT_WEBSOCKETS_GEN_QWEBSOCKETSERVER_H +#define MIQT_QT_WEBSOCKETS_GEN_QWEBSOCKETSERVER_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QChildEvent; +class QEvent; +class QHostAddress; +class QMetaMethod; +class QMetaObject; +class QNetworkProxy; +class QObject; +class QSslConfiguration; +class QSslError; +class QSslPreSharedKeyAuthenticator; +class QTcpSocket; +class QTimerEvent; +class QUrl; +class QWebSocket; +class QWebSocketCorsAuthenticator; +class QWebSocketServer; +#else +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QHostAddress QHostAddress; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QNetworkProxy QNetworkProxy; +typedef struct QObject QObject; +typedef struct QSslConfiguration QSslConfiguration; +typedef struct QSslError QSslError; +typedef struct QSslPreSharedKeyAuthenticator QSslPreSharedKeyAuthenticator; +typedef struct QTcpSocket QTcpSocket; +typedef struct QTimerEvent QTimerEvent; +typedef struct QUrl QUrl; +typedef struct QWebSocket QWebSocket; +typedef struct QWebSocketCorsAuthenticator QWebSocketCorsAuthenticator; +typedef struct QWebSocketServer QWebSocketServer; +#endif + +QWebSocketServer* QWebSocketServer_new(struct miqt_string serverName, int secureMode); +QWebSocketServer* QWebSocketServer_new2(struct miqt_string serverName, int secureMode, QObject* parent); +void QWebSocketServer_virtbase(QWebSocketServer* src, QObject** outptr_QObject); +QMetaObject* QWebSocketServer_metaObject(const QWebSocketServer* self); +void* QWebSocketServer_metacast(QWebSocketServer* self, const char* param1); +struct miqt_string QWebSocketServer_tr(const char* s); +struct miqt_string QWebSocketServer_trUtf8(const char* s); +bool QWebSocketServer_listen(QWebSocketServer* self); +void QWebSocketServer_close(QWebSocketServer* self); +bool QWebSocketServer_isListening(const QWebSocketServer* self); +void QWebSocketServer_setMaxPendingConnections(QWebSocketServer* self, int numConnections); +int QWebSocketServer_maxPendingConnections(const QWebSocketServer* self); +void QWebSocketServer_setHandshakeTimeoutWithMsec(QWebSocketServer* self, int msec); +int QWebSocketServer_handshakeTimeoutMS(const QWebSocketServer* self); +unsigned short QWebSocketServer_serverPort(const QWebSocketServer* self); +QHostAddress* QWebSocketServer_serverAddress(const QWebSocketServer* self); +QUrl* QWebSocketServer_serverUrl(const QWebSocketServer* self); +int QWebSocketServer_secureMode(const QWebSocketServer* self); +bool QWebSocketServer_setSocketDescriptor(QWebSocketServer* self, int socketDescriptor); +int QWebSocketServer_socketDescriptor(const QWebSocketServer* self); +bool QWebSocketServer_setNativeDescriptor(QWebSocketServer* self, intptr_t descriptor); +intptr_t QWebSocketServer_nativeDescriptor(const QWebSocketServer* self); +bool QWebSocketServer_hasPendingConnections(const QWebSocketServer* self); +QWebSocket* QWebSocketServer_nextPendingConnection(QWebSocketServer* self); +int QWebSocketServer_error(const QWebSocketServer* self); +struct miqt_string QWebSocketServer_errorString(const QWebSocketServer* self); +void QWebSocketServer_pauseAccepting(QWebSocketServer* self); +void QWebSocketServer_resumeAccepting(QWebSocketServer* self); +void QWebSocketServer_setServerName(QWebSocketServer* self, struct miqt_string serverName); +struct miqt_string QWebSocketServer_serverName(const QWebSocketServer* self); +void QWebSocketServer_setProxy(QWebSocketServer* self, QNetworkProxy* networkProxy); +QNetworkProxy* QWebSocketServer_proxy(const QWebSocketServer* self); +void QWebSocketServer_setSslConfiguration(QWebSocketServer* self, QSslConfiguration* sslConfiguration); +QSslConfiguration* QWebSocketServer_sslConfiguration(const QWebSocketServer* self); +struct miqt_array /* of int */ QWebSocketServer_supportedVersions(const QWebSocketServer* self); +void QWebSocketServer_handleConnection(const QWebSocketServer* self, QTcpSocket* socket); +void QWebSocketServer_acceptError(QWebSocketServer* self, int socketError); +void QWebSocketServer_connect_acceptError(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_serverError(QWebSocketServer* self, int closeCode); +void QWebSocketServer_connect_serverError(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_originAuthenticationRequired(QWebSocketServer* self, QWebSocketCorsAuthenticator* pAuthenticator); +void QWebSocketServer_connect_originAuthenticationRequired(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_newConnection(QWebSocketServer* self); +void QWebSocketServer_connect_newConnection(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_peerVerifyError(QWebSocketServer* self, QSslError* error); +void QWebSocketServer_connect_peerVerifyError(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_sslErrors(QWebSocketServer* self, struct miqt_array /* of QSslError* */ errors); +void QWebSocketServer_connect_sslErrors(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_preSharedKeyAuthenticationRequired(QWebSocketServer* self, QSslPreSharedKeyAuthenticator* authenticator); +void QWebSocketServer_connect_preSharedKeyAuthenticationRequired(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_closed(QWebSocketServer* self); +void QWebSocketServer_connect_closed(QWebSocketServer* self, intptr_t slot); +struct miqt_string QWebSocketServer_tr2(const char* s, const char* c); +struct miqt_string QWebSocketServer_tr3(const char* s, const char* c, int n); +struct miqt_string QWebSocketServer_trUtf82(const char* s, const char* c); +struct miqt_string QWebSocketServer_trUtf83(const char* s, const char* c, int n); +bool QWebSocketServer_listenWithAddress(QWebSocketServer* self, QHostAddress* address); +bool QWebSocketServer_listen2(QWebSocketServer* self, QHostAddress* address, unsigned short port); + +bool QWebSocketServer_override_virtual_nextPendingConnection(void* self, intptr_t slot); +QWebSocket* QWebSocketServer_virtualbase_nextPendingConnection(void* self); +bool QWebSocketServer_override_virtual_event(void* self, intptr_t slot); +bool QWebSocketServer_virtualbase_event(void* self, QEvent* event); +bool QWebSocketServer_override_virtual_eventFilter(void* self, intptr_t slot); +bool QWebSocketServer_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QWebSocketServer_override_virtual_timerEvent(void* self, intptr_t slot); +void QWebSocketServer_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QWebSocketServer_override_virtual_childEvent(void* self, intptr_t slot); +void QWebSocketServer_virtualbase_childEvent(void* self, QChildEvent* event); +bool QWebSocketServer_override_virtual_customEvent(void* self, intptr_t slot); +void QWebSocketServer_virtualbase_customEvent(void* self, QEvent* event); +bool QWebSocketServer_override_virtual_connectNotify(void* self, intptr_t slot); +void QWebSocketServer_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QWebSocketServer_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QWebSocketServer_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QWebSocketServer_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QWebSocketServer_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QWebSocketServer_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QWebSocketServer_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QWebSocketServer_delete(QWebSocketServer* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/websockets/cflags.go b/qt6/websockets/cflags.go new file mode 100644 index 000000000..bbdd61ad3 --- /dev/null +++ b/qt6/websockets/cflags.go @@ -0,0 +1,7 @@ +package websockets + +/* +#cgo pkg-config: Qt6WebSockets +*/ +import "C" + diff --git a/qt6/websockets/gen_qmaskgenerator.cpp b/qt6/websockets/gen_qmaskgenerator.cpp new file mode 100644 index 000000000..2928fe366 --- /dev/null +++ b/qt6/websockets/gen_qmaskgenerator.cpp @@ -0,0 +1,376 @@ +#include +#include +#include +#include +#include +#include +#include +#include "gen_qmaskgenerator.h" + +#ifdef __cplusplus +extern "C" { +#endif + +bool miqt_exec_callback_QMaskGenerator_seed(QMaskGenerator*, intptr_t); +unsigned int miqt_exec_callback_QMaskGenerator_nextMask(QMaskGenerator*, intptr_t); +bool miqt_exec_callback_QMaskGenerator_event(QMaskGenerator*, intptr_t, QEvent*); +bool miqt_exec_callback_QMaskGenerator_eventFilter(QMaskGenerator*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QMaskGenerator_timerEvent(QMaskGenerator*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QMaskGenerator_childEvent(QMaskGenerator*, intptr_t, QChildEvent*); +void miqt_exec_callback_QMaskGenerator_customEvent(QMaskGenerator*, intptr_t, QEvent*); +void miqt_exec_callback_QMaskGenerator_connectNotify(QMaskGenerator*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QMaskGenerator_disconnectNotify(QMaskGenerator*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQMaskGenerator final : public QMaskGenerator { +public: + + MiqtVirtualQMaskGenerator(): QMaskGenerator() {} + MiqtVirtualQMaskGenerator(QObject* parent): QMaskGenerator(parent) {} + + virtual ~MiqtVirtualQMaskGenerator() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__seed = 0; + + // Subclass to allow providing a Go implementation + virtual bool seed() override { + if (handle__seed == 0) { + return false; // Pure virtual, there is no base we can call + } + + bool callback_return_value = miqt_exec_callback_QMaskGenerator_seed(this, handle__seed); + return callback_return_value; + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__nextMask = 0; + + // Subclass to allow providing a Go implementation + virtual quint32 nextMask() override { + if (handle__nextMask == 0) { + return 0; // Pure virtual, there is no base we can call + } + + unsigned int callback_return_value = miqt_exec_callback_QMaskGenerator_nextMask(this, handle__nextMask); + return static_cast(callback_return_value); + } + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QMaskGenerator::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QMaskGenerator_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QMaskGenerator_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QMaskGenerator::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QMaskGenerator_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QMaskGenerator_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) { + QMaskGenerator::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QMaskGenerator_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QMaskGenerator_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) { + QMaskGenerator::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QMaskGenerator_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QMaskGenerator_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) { + QMaskGenerator::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QMaskGenerator_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QMaskGenerator_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) { + QMaskGenerator::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QMaskGenerator_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QMaskGenerator_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) { + QMaskGenerator::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QMaskGenerator_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QMaskGenerator_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QMaskGenerator_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QMaskGenerator_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QMaskGenerator_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QMaskGenerator_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QMaskGenerator* QMaskGenerator_new() { + return new (std::nothrow) MiqtVirtualQMaskGenerator(); +} + +QMaskGenerator* QMaskGenerator_new2(QObject* parent) { + return new (std::nothrow) MiqtVirtualQMaskGenerator(parent); +} + +void QMaskGenerator_virtbase(QMaskGenerator* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +bool QMaskGenerator_seed(QMaskGenerator* self) { + return self->seed(); +} + +unsigned int QMaskGenerator_nextMask(QMaskGenerator* self) { + quint32 _ret = self->nextMask(); + return static_cast(_ret); +} + +bool QMaskGenerator_override_virtual_seed(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__seed = slot; + return true; +} + +bool QMaskGenerator_override_virtual_nextMask(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__nextMask = slot; + return true; +} + +bool QMaskGenerator_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QMaskGenerator_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QMaskGenerator::event(event); +} + +bool QMaskGenerator_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QMaskGenerator_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QMaskGenerator::eventFilter(watched, event); +} + +bool QMaskGenerator_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QMaskGenerator_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QMaskGenerator::timerEvent(event); +} + +bool QMaskGenerator_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QMaskGenerator_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QMaskGenerator::childEvent(event); +} + +bool QMaskGenerator_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QMaskGenerator_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QMaskGenerator::customEvent(event); +} + +bool QMaskGenerator_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QMaskGenerator_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QMaskGenerator::connectNotify(*signal); +} + +bool QMaskGenerator_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QMaskGenerator_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QMaskGenerator::disconnectNotify(*signal); +} + +QObject* QMaskGenerator_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QMaskGenerator_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QMaskGenerator_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QMaskGenerator_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQMaskGenerator* self_cast = dynamic_cast( (QMaskGenerator*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QMaskGenerator_delete(QMaskGenerator* self) { + delete self; +} + diff --git a/qt6/websockets/gen_qmaskgenerator.go b/qt6/websockets/gen_qmaskgenerator.go new file mode 100644 index 000000000..9e8d7a4d5 --- /dev/null +++ b/qt6/websockets/gen_qmaskgenerator.go @@ -0,0 +1,370 @@ +package websockets + +/* + +#include "gen_qmaskgenerator.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QMaskGenerator struct { + h *C.QMaskGenerator + *qt6.QObject +} + +func (this *QMaskGenerator) cPointer() *C.QMaskGenerator { + if this == nil { + return nil + } + return this.h +} + +func (this *QMaskGenerator) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQMaskGenerator constructs the type using only CGO pointers. +func newQMaskGenerator(h *C.QMaskGenerator) *QMaskGenerator { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QMaskGenerator_virtbase(h, &outptr_QObject) + + return &QMaskGenerator{h: h, + QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQMaskGenerator constructs the type using only unsafe pointers. +func UnsafeNewQMaskGenerator(h unsafe.Pointer) *QMaskGenerator { + return newQMaskGenerator((*C.QMaskGenerator)(h)) +} + +// NewQMaskGenerator constructs a new QMaskGenerator object. +func NewQMaskGenerator() *QMaskGenerator { + + return newQMaskGenerator(C.QMaskGenerator_new()) +} + +// NewQMaskGenerator2 constructs a new QMaskGenerator object. +func NewQMaskGenerator2(parent *qt6.QObject) *QMaskGenerator { + + return newQMaskGenerator(C.QMaskGenerator_new2((*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QMaskGenerator) Seed() bool { + return (bool)(C.QMaskGenerator_seed(this.h)) +} + +func (this *QMaskGenerator) NextMask() uint { + return (uint)(C.QMaskGenerator_nextMask(this.h)) +} + +// Sender can only be called from a QMaskGenerator that was directly constructed. +func (this *QMaskGenerator) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QMaskGenerator_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 QMaskGenerator that was directly constructed. +func (this *QMaskGenerator) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QMaskGenerator_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 QMaskGenerator that was directly constructed. +func (this *QMaskGenerator) 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.QMaskGenerator_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 QMaskGenerator that was directly constructed. +func (this *QMaskGenerator) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QMaskGenerator_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 *QMaskGenerator) OnSeed(slot func() bool) { + ok := C.QMaskGenerator_override_virtual_seed(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QMaskGenerator_seed +func miqt_exec_callback_QMaskGenerator_seed(self *C.QMaskGenerator, cb C.intptr_t) C.bool { + gofunc, ok := cgo.Handle(cb).Value().(func() bool) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc() + + return (C.bool)(virtualReturn) + +} +func (this *QMaskGenerator) OnNextMask(slot func() uint) { + ok := C.QMaskGenerator_override_virtual_nextMask(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QMaskGenerator_nextMask +func miqt_exec_callback_QMaskGenerator_nextMask(self *C.QMaskGenerator, cb C.intptr_t) C.uint { + gofunc, ok := cgo.Handle(cb).Value().(func() uint) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc() + + return (C.uint)(virtualReturn) + +} + +func (this *QMaskGenerator) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QMaskGenerator_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QMaskGenerator) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QMaskGenerator_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_QMaskGenerator_event +func miqt_exec_callback_QMaskGenerator_event(self *C.QMaskGenerator, 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((&QMaskGenerator{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QMaskGenerator) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QMaskGenerator_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QMaskGenerator) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QMaskGenerator_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_QMaskGenerator_eventFilter +func miqt_exec_callback_QMaskGenerator_eventFilter(self *C.QMaskGenerator, 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((&QMaskGenerator{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QMaskGenerator) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QMaskGenerator_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QMaskGenerator) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QMaskGenerator_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_QMaskGenerator_timerEvent +func miqt_exec_callback_QMaskGenerator_timerEvent(self *C.QMaskGenerator, 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((&QMaskGenerator{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QMaskGenerator) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QMaskGenerator_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QMaskGenerator) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QMaskGenerator_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_QMaskGenerator_childEvent +func miqt_exec_callback_QMaskGenerator_childEvent(self *C.QMaskGenerator, 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((&QMaskGenerator{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QMaskGenerator) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QMaskGenerator_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QMaskGenerator) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QMaskGenerator_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_QMaskGenerator_customEvent +func miqt_exec_callback_QMaskGenerator_customEvent(self *C.QMaskGenerator, 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((&QMaskGenerator{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QMaskGenerator) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QMaskGenerator_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QMaskGenerator) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QMaskGenerator_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_QMaskGenerator_connectNotify +func miqt_exec_callback_QMaskGenerator_connectNotify(self *C.QMaskGenerator, 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((&QMaskGenerator{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QMaskGenerator) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QMaskGenerator_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QMaskGenerator) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QMaskGenerator_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_QMaskGenerator_disconnectNotify +func miqt_exec_callback_QMaskGenerator_disconnectNotify(self *C.QMaskGenerator, 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((&QMaskGenerator{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QMaskGenerator) Delete() { + C.QMaskGenerator_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 *QMaskGenerator) GoGC() { + runtime.SetFinalizer(this, func(this *QMaskGenerator) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/websockets/gen_qmaskgenerator.h b/qt6/websockets/gen_qmaskgenerator.h new file mode 100644 index 000000000..1a2ae08de --- /dev/null +++ b/qt6/websockets/gen_qmaskgenerator.h @@ -0,0 +1,69 @@ +#pragma once +#ifndef MIQT_QT6_WEBSOCKETS_GEN_QMASKGENERATOR_H +#define MIQT_QT6_WEBSOCKETS_GEN_QMASKGENERATOR_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QChildEvent; +class QEvent; +class QMaskGenerator; +class QMetaMethod; +class QObject; +class QTimerEvent; +#else +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QMaskGenerator QMaskGenerator; +typedef struct QMetaMethod QMetaMethod; +typedef struct QObject QObject; +typedef struct QTimerEvent QTimerEvent; +#endif + +QMaskGenerator* QMaskGenerator_new(); +QMaskGenerator* QMaskGenerator_new2(QObject* parent); +void QMaskGenerator_virtbase(QMaskGenerator* src, QObject** outptr_QObject); +bool QMaskGenerator_seed(QMaskGenerator* self); +unsigned int QMaskGenerator_nextMask(QMaskGenerator* self); + +bool QMaskGenerator_override_virtual_seed(void* self, intptr_t slot); +bool QMaskGenerator_virtualbase_seed(void* self); +bool QMaskGenerator_override_virtual_nextMask(void* self, intptr_t slot); +unsigned int QMaskGenerator_virtualbase_nextMask(void* self); +bool QMaskGenerator_override_virtual_event(void* self, intptr_t slot); +bool QMaskGenerator_virtualbase_event(void* self, QEvent* event); +bool QMaskGenerator_override_virtual_eventFilter(void* self, intptr_t slot); +bool QMaskGenerator_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QMaskGenerator_override_virtual_timerEvent(void* self, intptr_t slot); +void QMaskGenerator_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QMaskGenerator_override_virtual_childEvent(void* self, intptr_t slot); +void QMaskGenerator_virtualbase_childEvent(void* self, QChildEvent* event); +bool QMaskGenerator_override_virtual_customEvent(void* self, intptr_t slot); +void QMaskGenerator_virtualbase_customEvent(void* self, QEvent* event); +bool QMaskGenerator_override_virtual_connectNotify(void* self, intptr_t slot); +void QMaskGenerator_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QMaskGenerator_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QMaskGenerator_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QMaskGenerator_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QMaskGenerator_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QMaskGenerator_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QMaskGenerator_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QMaskGenerator_delete(QMaskGenerator* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/websockets/gen_qwebsocket.cpp b/qt6/websockets/gen_qwebsocket.cpp new file mode 100644 index 000000000..eff9c40ab --- /dev/null +++ b/qt6/websockets/gen_qwebsocket.cpp @@ -0,0 +1,989 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qwebsocket.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QWebSocket_aboutToClose(intptr_t); +void miqt_exec_callback_QWebSocket_connected(intptr_t); +void miqt_exec_callback_QWebSocket_disconnected(intptr_t); +void miqt_exec_callback_QWebSocket_stateChanged(intptr_t, int); +void miqt_exec_callback_QWebSocket_proxyAuthenticationRequired(intptr_t, QNetworkProxy*, QAuthenticator*); +void miqt_exec_callback_QWebSocket_readChannelFinished(intptr_t); +void miqt_exec_callback_QWebSocket_textFrameReceived(intptr_t, struct miqt_string, bool); +void miqt_exec_callback_QWebSocket_binaryFrameReceived(intptr_t, struct miqt_string, bool); +void miqt_exec_callback_QWebSocket_textMessageReceived(intptr_t, struct miqt_string); +void miqt_exec_callback_QWebSocket_binaryMessageReceived(intptr_t, struct miqt_string); +void miqt_exec_callback_QWebSocket_errorWithError(intptr_t, int); +void miqt_exec_callback_QWebSocket_pong(intptr_t, unsigned long long, struct miqt_string); +void miqt_exec_callback_QWebSocket_bytesWritten(intptr_t, long long); +void miqt_exec_callback_QWebSocket_peerVerifyError(intptr_t, QSslError*); +void miqt_exec_callback_QWebSocket_sslErrors(intptr_t, struct miqt_array /* of QSslError* */ ); +void miqt_exec_callback_QWebSocket_preSharedKeyAuthenticationRequired(intptr_t, QSslPreSharedKeyAuthenticator*); +void miqt_exec_callback_QWebSocket_alertSent(intptr_t, int, int, struct miqt_string); +void miqt_exec_callback_QWebSocket_alertReceived(intptr_t, int, int, struct miqt_string); +void miqt_exec_callback_QWebSocket_handshakeInterruptedOnError(intptr_t, QSslError*); +bool miqt_exec_callback_QWebSocket_event(QWebSocket*, intptr_t, QEvent*); +bool miqt_exec_callback_QWebSocket_eventFilter(QWebSocket*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QWebSocket_timerEvent(QWebSocket*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QWebSocket_childEvent(QWebSocket*, intptr_t, QChildEvent*); +void miqt_exec_callback_QWebSocket_customEvent(QWebSocket*, intptr_t, QEvent*); +void miqt_exec_callback_QWebSocket_connectNotify(QWebSocket*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QWebSocket_disconnectNotify(QWebSocket*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQWebSocket final : public QWebSocket { +public: + + MiqtVirtualQWebSocket(): QWebSocket() {} + MiqtVirtualQWebSocket(const QString& origin): QWebSocket(origin) {} + MiqtVirtualQWebSocket(const QString& origin, QWebSocketProtocol::Version version): QWebSocket(origin, version) {} + MiqtVirtualQWebSocket(const QString& origin, QWebSocketProtocol::Version version, QObject* parent): QWebSocket(origin, version, parent) {} + + virtual ~MiqtVirtualQWebSocket() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QWebSocket::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QWebSocket_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QWebSocket_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QWebSocket::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QWebSocket_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QWebSocket_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) { + QWebSocket::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QWebSocket_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QWebSocket_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) { + QWebSocket::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QWebSocket_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QWebSocket_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) { + QWebSocket::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QWebSocket_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QWebSocket_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) { + QWebSocket::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QWebSocket_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QWebSocket_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) { + QWebSocket::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QWebSocket_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QWebSocket_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QWebSocket_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QWebSocket_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QWebSocket_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QWebSocket_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QWebSocket* QWebSocket_new() { + return new (std::nothrow) MiqtVirtualQWebSocket(); +} + +QWebSocket* QWebSocket_new2(struct miqt_string origin) { + QString origin_QString = QString::fromUtf8(origin.data, origin.len); + return new (std::nothrow) MiqtVirtualQWebSocket(origin_QString); +} + +QWebSocket* QWebSocket_new3(struct miqt_string origin, int version) { + QString origin_QString = QString::fromUtf8(origin.data, origin.len); + return new (std::nothrow) MiqtVirtualQWebSocket(origin_QString, static_cast(version)); +} + +QWebSocket* QWebSocket_new4(struct miqt_string origin, int version, QObject* parent) { + QString origin_QString = QString::fromUtf8(origin.data, origin.len); + return new (std::nothrow) MiqtVirtualQWebSocket(origin_QString, static_cast(version), parent); +} + +void QWebSocket_virtbase(QWebSocket* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QWebSocket_metaObject(const QWebSocket* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QWebSocket_metacast(QWebSocket* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QWebSocket_tr(const char* s) { + QString _ret = QWebSocket::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 QWebSocket_abort(QWebSocket* self) { + self->abort(); +} + +int QWebSocket_error(const QWebSocket* self) { + QAbstractSocket::SocketError _ret = self->error(); + return static_cast(_ret); +} + +struct miqt_string QWebSocket_errorString(const QWebSocket* 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; +} + +bool QWebSocket_flush(QWebSocket* self) { + return self->flush(); +} + +bool QWebSocket_isValid(const QWebSocket* self) { + return self->isValid(); +} + +QHostAddress* QWebSocket_localAddress(const QWebSocket* self) { + return new QHostAddress(self->localAddress()); +} + +unsigned short QWebSocket_localPort(const QWebSocket* self) { + quint16 _ret = self->localPort(); + return static_cast(_ret); +} + +int QWebSocket_pauseMode(const QWebSocket* self) { + QAbstractSocket::PauseModes _ret = self->pauseMode(); + return static_cast(_ret); +} + +QHostAddress* QWebSocket_peerAddress(const QWebSocket* self) { + return new QHostAddress(self->peerAddress()); +} + +struct miqt_string QWebSocket_peerName(const QWebSocket* self) { + QString _ret = self->peerName(); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +unsigned short QWebSocket_peerPort(const QWebSocket* self) { + quint16 _ret = self->peerPort(); + return static_cast(_ret); +} + +QNetworkProxy* QWebSocket_proxy(const QWebSocket* self) { + return new QNetworkProxy(self->proxy()); +} + +void QWebSocket_setProxy(QWebSocket* self, QNetworkProxy* networkProxy) { + self->setProxy(*networkProxy); +} + +void QWebSocket_setMaskGenerator(QWebSocket* self, QMaskGenerator* maskGenerator) { + self->setMaskGenerator(maskGenerator); +} + +QMaskGenerator* QWebSocket_maskGenerator(const QWebSocket* self) { + return (QMaskGenerator*) self->maskGenerator(); +} + +long long QWebSocket_readBufferSize(const QWebSocket* self) { + qint64 _ret = self->readBufferSize(); + return static_cast(_ret); +} + +void QWebSocket_setReadBufferSize(QWebSocket* self, long long size) { + self->setReadBufferSize(static_cast(size)); +} + +void QWebSocket_resume(QWebSocket* self) { + self->resume(); +} + +void QWebSocket_setPauseMode(QWebSocket* self, int pauseMode) { + self->setPauseMode(static_cast(pauseMode)); +} + +int QWebSocket_state(const QWebSocket* self) { + QAbstractSocket::SocketState _ret = self->state(); + return static_cast(_ret); +} + +int QWebSocket_version(const QWebSocket* self) { + QWebSocketProtocol::Version _ret = self->version(); + return static_cast(_ret); +} + +struct miqt_string QWebSocket_resourceName(const QWebSocket* self) { + QString _ret = self->resourceName(); + // 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; +} + +QUrl* QWebSocket_requestUrl(const QWebSocket* self) { + return new QUrl(self->requestUrl()); +} + +QNetworkRequest* QWebSocket_request(const QWebSocket* self) { + return new QNetworkRequest(self->request()); +} + +QWebSocketHandshakeOptions* QWebSocket_handshakeOptions(const QWebSocket* self) { + return new QWebSocketHandshakeOptions(self->handshakeOptions()); +} + +struct miqt_string QWebSocket_origin(const QWebSocket* self) { + QString _ret = self->origin(); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +struct miqt_string QWebSocket_subprotocol(const QWebSocket* self) { + QString _ret = self->subprotocol(); + // 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 QWebSocket_closeCode(const QWebSocket* self) { + QWebSocketProtocol::CloseCode _ret = self->closeCode(); + return static_cast(_ret); +} + +struct miqt_string QWebSocket_closeReason(const QWebSocket* self) { + QString _ret = self->closeReason(); + // 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; +} + +long long QWebSocket_sendTextMessage(QWebSocket* self, struct miqt_string message) { + QString message_QString = QString::fromUtf8(message.data, message.len); + qint64 _ret = self->sendTextMessage(message_QString); + return static_cast(_ret); +} + +long long QWebSocket_sendBinaryMessage(QWebSocket* self, struct miqt_string data) { + QByteArray data_QByteArray(data.data, data.len); + qint64 _ret = self->sendBinaryMessage(data_QByteArray); + return static_cast(_ret); +} + +void QWebSocket_ignoreSslErrors(QWebSocket* self, struct miqt_array /* of QSslError* */ errors) { + QList errors_QList; + errors_QList.reserve(errors.len); + QSslError** errors_arr = static_cast(errors.data); + for(size_t i = 0; i < errors.len; ++i) { + errors_QList.push_back(*(errors_arr[i])); + } + self->ignoreSslErrors(errors_QList); +} + +void QWebSocket_continueInterruptedHandshake(QWebSocket* self) { + self->continueInterruptedHandshake(); +} + +void QWebSocket_setSslConfiguration(QWebSocket* self, QSslConfiguration* sslConfiguration) { + self->setSslConfiguration(*sslConfiguration); +} + +QSslConfiguration* QWebSocket_sslConfiguration(const QWebSocket* self) { + return new QSslConfiguration(self->sslConfiguration()); +} + +long long QWebSocket_bytesToWrite(const QWebSocket* self) { + qint64 _ret = self->bytesToWrite(); + return static_cast(_ret); +} + +void QWebSocket_setMaxAllowedIncomingFrameSize(QWebSocket* self, unsigned long long maxAllowedIncomingFrameSize) { + self->setMaxAllowedIncomingFrameSize(static_cast(maxAllowedIncomingFrameSize)); +} + +unsigned long long QWebSocket_maxAllowedIncomingFrameSize(const QWebSocket* self) { + quint64 _ret = self->maxAllowedIncomingFrameSize(); + return static_cast(_ret); +} + +void QWebSocket_setMaxAllowedIncomingMessageSize(QWebSocket* self, unsigned long long maxAllowedIncomingMessageSize) { + self->setMaxAllowedIncomingMessageSize(static_cast(maxAllowedIncomingMessageSize)); +} + +unsigned long long QWebSocket_maxAllowedIncomingMessageSize(const QWebSocket* self) { + quint64 _ret = self->maxAllowedIncomingMessageSize(); + return static_cast(_ret); +} + +unsigned long long QWebSocket_maxIncomingMessageSize() { + quint64 _ret = QWebSocket::maxIncomingMessageSize(); + return static_cast(_ret); +} + +unsigned long long QWebSocket_maxIncomingFrameSize() { + quint64 _ret = QWebSocket::maxIncomingFrameSize(); + return static_cast(_ret); +} + +void QWebSocket_setOutgoingFrameSize(QWebSocket* self, unsigned long long outgoingFrameSize) { + self->setOutgoingFrameSize(static_cast(outgoingFrameSize)); +} + +unsigned long long QWebSocket_outgoingFrameSize(const QWebSocket* self) { + quint64 _ret = self->outgoingFrameSize(); + return static_cast(_ret); +} + +unsigned long long QWebSocket_maxOutgoingFrameSize() { + quint64 _ret = QWebSocket::maxOutgoingFrameSize(); + return static_cast(_ret); +} + +void QWebSocket_close(QWebSocket* self) { + self->close(); +} + +void QWebSocket_open(QWebSocket* self, QUrl* url) { + self->open(*url); +} + +void QWebSocket_openWithRequest(QWebSocket* self, QNetworkRequest* request) { + self->open(*request); +} + +void QWebSocket_open2(QWebSocket* self, QUrl* url, QWebSocketHandshakeOptions* options) { + self->open(*url, *options); +} + +void QWebSocket_open3(QWebSocket* self, QNetworkRequest* request, QWebSocketHandshakeOptions* options) { + self->open(*request, *options); +} + +void QWebSocket_ping(QWebSocket* self) { + self->ping(); +} + +void QWebSocket_ignoreSslErrors2(QWebSocket* self) { + self->ignoreSslErrors(); +} + +void QWebSocket_aboutToClose(QWebSocket* self) { + self->aboutToClose(); +} + +void QWebSocket_connect_aboutToClose(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::aboutToClose), self, [=]() { + miqt_exec_callback_QWebSocket_aboutToClose(slot); + }); +} + +void QWebSocket_connected(QWebSocket* self) { + self->connected(); +} + +void QWebSocket_connect_connected(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::connected), self, [=]() { + miqt_exec_callback_QWebSocket_connected(slot); + }); +} + +void QWebSocket_disconnected(QWebSocket* self) { + self->disconnected(); +} + +void QWebSocket_connect_disconnected(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::disconnected), self, [=]() { + miqt_exec_callback_QWebSocket_disconnected(slot); + }); +} + +void QWebSocket_stateChanged(QWebSocket* self, int state) { + self->stateChanged(static_cast(state)); +} + +void QWebSocket_connect_stateChanged(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::stateChanged), self, [=](QAbstractSocket::SocketState state) { + QAbstractSocket::SocketState state_ret = state; + int sigval1 = static_cast(state_ret); + miqt_exec_callback_QWebSocket_stateChanged(slot, sigval1); + }); +} + +void QWebSocket_proxyAuthenticationRequired(QWebSocket* self, QNetworkProxy* proxy, QAuthenticator* pAuthenticator) { + self->proxyAuthenticationRequired(*proxy, pAuthenticator); +} + +void QWebSocket_connect_proxyAuthenticationRequired(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::proxyAuthenticationRequired), self, [=](const QNetworkProxy& proxy, QAuthenticator* pAuthenticator) { + const QNetworkProxy& proxy_ret = proxy; + // Cast returned reference into pointer + QNetworkProxy* sigval1 = const_cast(&proxy_ret); + QAuthenticator* sigval2 = pAuthenticator; + miqt_exec_callback_QWebSocket_proxyAuthenticationRequired(slot, sigval1, sigval2); + }); +} + +void QWebSocket_readChannelFinished(QWebSocket* self) { + self->readChannelFinished(); +} + +void QWebSocket_connect_readChannelFinished(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::readChannelFinished), self, [=]() { + miqt_exec_callback_QWebSocket_readChannelFinished(slot); + }); +} + +void QWebSocket_textFrameReceived(QWebSocket* self, struct miqt_string frame, bool isLastFrame) { + QString frame_QString = QString::fromUtf8(frame.data, frame.len); + self->textFrameReceived(frame_QString, isLastFrame); +} + +void QWebSocket_connect_textFrameReceived(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::textFrameReceived), self, [=](const QString& frame, bool isLastFrame) { + const QString frame_ret = frame; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray frame_b = frame_ret.toUtf8(); + struct miqt_string frame_ms; + frame_ms.len = frame_b.length(); + frame_ms.data = static_cast(malloc(frame_ms.len)); + memcpy(frame_ms.data, frame_b.data(), frame_ms.len); + struct miqt_string sigval1 = frame_ms; + bool sigval2 = isLastFrame; + miqt_exec_callback_QWebSocket_textFrameReceived(slot, sigval1, sigval2); + }); +} + +void QWebSocket_binaryFrameReceived(QWebSocket* self, struct miqt_string frame, bool isLastFrame) { + QByteArray frame_QByteArray(frame.data, frame.len); + self->binaryFrameReceived(frame_QByteArray, isLastFrame); +} + +void QWebSocket_connect_binaryFrameReceived(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::binaryFrameReceived), self, [=](const QByteArray& frame, bool isLastFrame) { + const QByteArray frame_qb = frame; + struct miqt_string frame_ms; + frame_ms.len = frame_qb.length(); + frame_ms.data = static_cast(malloc(frame_ms.len)); + memcpy(frame_ms.data, frame_qb.data(), frame_ms.len); + struct miqt_string sigval1 = frame_ms; + bool sigval2 = isLastFrame; + miqt_exec_callback_QWebSocket_binaryFrameReceived(slot, sigval1, sigval2); + }); +} + +void QWebSocket_textMessageReceived(QWebSocket* self, struct miqt_string message) { + QString message_QString = QString::fromUtf8(message.data, message.len); + self->textMessageReceived(message_QString); +} + +void QWebSocket_connect_textMessageReceived(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::textMessageReceived), self, [=](const QString& message) { + const QString message_ret = message; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray message_b = message_ret.toUtf8(); + struct miqt_string message_ms; + message_ms.len = message_b.length(); + message_ms.data = static_cast(malloc(message_ms.len)); + memcpy(message_ms.data, message_b.data(), message_ms.len); + struct miqt_string sigval1 = message_ms; + miqt_exec_callback_QWebSocket_textMessageReceived(slot, sigval1); + }); +} + +void QWebSocket_binaryMessageReceived(QWebSocket* self, struct miqt_string message) { + QByteArray message_QByteArray(message.data, message.len); + self->binaryMessageReceived(message_QByteArray); +} + +void QWebSocket_connect_binaryMessageReceived(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::binaryMessageReceived), self, [=](const QByteArray& message) { + const QByteArray message_qb = message; + struct miqt_string message_ms; + message_ms.len = message_qb.length(); + message_ms.data = static_cast(malloc(message_ms.len)); + memcpy(message_ms.data, message_qb.data(), message_ms.len); + struct miqt_string sigval1 = message_ms; + miqt_exec_callback_QWebSocket_binaryMessageReceived(slot, sigval1); + }); +} + +void QWebSocket_errorWithError(QWebSocket* self, int error) { + self->error(static_cast(error)); +} + +void QWebSocket_connect_errorWithError(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::error), self, [=](QAbstractSocket::SocketError error) { + QAbstractSocket::SocketError error_ret = error; + int sigval1 = static_cast(error_ret); + miqt_exec_callback_QWebSocket_errorWithError(slot, sigval1); + }); +} + +void QWebSocket_pong(QWebSocket* self, unsigned long long elapsedTime, struct miqt_string payload) { + QByteArray payload_QByteArray(payload.data, payload.len); + self->pong(static_cast(elapsedTime), payload_QByteArray); +} + +void QWebSocket_connect_pong(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::pong), self, [=](quint64 elapsedTime, const QByteArray& payload) { + quint64 elapsedTime_ret = elapsedTime; + unsigned long long sigval1 = static_cast(elapsedTime_ret); + const QByteArray payload_qb = payload; + struct miqt_string payload_ms; + payload_ms.len = payload_qb.length(); + payload_ms.data = static_cast(malloc(payload_ms.len)); + memcpy(payload_ms.data, payload_qb.data(), payload_ms.len); + struct miqt_string sigval2 = payload_ms; + miqt_exec_callback_QWebSocket_pong(slot, sigval1, sigval2); + }); +} + +void QWebSocket_bytesWritten(QWebSocket* self, long long bytes) { + self->bytesWritten(static_cast(bytes)); +} + +void QWebSocket_connect_bytesWritten(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::bytesWritten), self, [=](qint64 bytes) { + qint64 bytes_ret = bytes; + long long sigval1 = static_cast(bytes_ret); + miqt_exec_callback_QWebSocket_bytesWritten(slot, sigval1); + }); +} + +void QWebSocket_peerVerifyError(QWebSocket* self, QSslError* error) { + self->peerVerifyError(*error); +} + +void QWebSocket_connect_peerVerifyError(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::peerVerifyError), self, [=](const QSslError& error) { + const QSslError& error_ret = error; + // Cast returned reference into pointer + QSslError* sigval1 = const_cast(&error_ret); + miqt_exec_callback_QWebSocket_peerVerifyError(slot, sigval1); + }); +} + +void QWebSocket_sslErrors(QWebSocket* self, struct miqt_array /* of QSslError* */ errors) { + QList errors_QList; + errors_QList.reserve(errors.len); + QSslError** errors_arr = static_cast(errors.data); + for(size_t i = 0; i < errors.len; ++i) { + errors_QList.push_back(*(errors_arr[i])); + } + self->sslErrors(errors_QList); +} + +void QWebSocket_connect_sslErrors(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast&)>(&QWebSocket::sslErrors), self, [=](const QList& errors) { + const QList& errors_ret = errors; + // Convert QList<> from C++ memory to manually-managed C memory + QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.length())); + for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { + errors_arr[i] = new QSslError(errors_ret[i]); + } + struct miqt_array errors_out; + errors_out.len = errors_ret.length(); + errors_out.data = static_cast(errors_arr); + struct miqt_array /* of QSslError* */ sigval1 = errors_out; + miqt_exec_callback_QWebSocket_sslErrors(slot, sigval1); + }); +} + +void QWebSocket_preSharedKeyAuthenticationRequired(QWebSocket* self, QSslPreSharedKeyAuthenticator* authenticator) { + self->preSharedKeyAuthenticationRequired(authenticator); +} + +void QWebSocket_connect_preSharedKeyAuthenticationRequired(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::preSharedKeyAuthenticationRequired), self, [=](QSslPreSharedKeyAuthenticator* authenticator) { + QSslPreSharedKeyAuthenticator* sigval1 = authenticator; + miqt_exec_callback_QWebSocket_preSharedKeyAuthenticationRequired(slot, sigval1); + }); +} + +void QWebSocket_alertSent(QWebSocket* self, int level, int type, struct miqt_string description) { + QString description_QString = QString::fromUtf8(description.data, description.len); + self->alertSent(static_cast(level), static_cast(type), description_QString); +} + +void QWebSocket_connect_alertSent(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::alertSent), self, [=](QSsl::AlertLevel level, QSsl::AlertType type, const QString& description) { + QSsl::AlertLevel level_ret = level; + int sigval1 = static_cast(level_ret); + QSsl::AlertType type_ret = type; + int sigval2 = static_cast(type_ret); + const QString description_ret = description; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray description_b = description_ret.toUtf8(); + struct miqt_string description_ms; + description_ms.len = description_b.length(); + description_ms.data = static_cast(malloc(description_ms.len)); + memcpy(description_ms.data, description_b.data(), description_ms.len); + struct miqt_string sigval3 = description_ms; + miqt_exec_callback_QWebSocket_alertSent(slot, sigval1, sigval2, sigval3); + }); +} + +void QWebSocket_alertReceived(QWebSocket* self, int level, int type, struct miqt_string description) { + QString description_QString = QString::fromUtf8(description.data, description.len); + self->alertReceived(static_cast(level), static_cast(type), description_QString); +} + +void QWebSocket_connect_alertReceived(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::alertReceived), self, [=](QSsl::AlertLevel level, QSsl::AlertType type, const QString& description) { + QSsl::AlertLevel level_ret = level; + int sigval1 = static_cast(level_ret); + QSsl::AlertType type_ret = type; + int sigval2 = static_cast(type_ret); + const QString description_ret = description; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray description_b = description_ret.toUtf8(); + struct miqt_string description_ms; + description_ms.len = description_b.length(); + description_ms.data = static_cast(malloc(description_ms.len)); + memcpy(description_ms.data, description_b.data(), description_ms.len); + struct miqt_string sigval3 = description_ms; + miqt_exec_callback_QWebSocket_alertReceived(slot, sigval1, sigval2, sigval3); + }); +} + +void QWebSocket_handshakeInterruptedOnError(QWebSocket* self, QSslError* error) { + self->handshakeInterruptedOnError(*error); +} + +void QWebSocket_connect_handshakeInterruptedOnError(QWebSocket* self, intptr_t slot) { + QWebSocket::connect(self, static_cast(&QWebSocket::handshakeInterruptedOnError), self, [=](const QSslError& error) { + const QSslError& error_ret = error; + // Cast returned reference into pointer + QSslError* sigval1 = const_cast(&error_ret); + miqt_exec_callback_QWebSocket_handshakeInterruptedOnError(slot, sigval1); + }); +} + +struct miqt_string QWebSocket_tr2(const char* s, const char* c) { + QString _ret = QWebSocket::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 QWebSocket_tr3(const char* s, const char* c, int n) { + QString _ret = QWebSocket::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 QWebSocket_closeWithCloseCode(QWebSocket* self, int closeCode) { + self->close(static_cast(closeCode)); +} + +void QWebSocket_close2(QWebSocket* self, int closeCode, struct miqt_string reason) { + QString reason_QString = QString::fromUtf8(reason.data, reason.len); + self->close(static_cast(closeCode), reason_QString); +} + +void QWebSocket_pingWithPayload(QWebSocket* self, struct miqt_string payload) { + QByteArray payload_QByteArray(payload.data, payload.len); + self->ping(payload_QByteArray); +} + +bool QWebSocket_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QWebSocket_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QWebSocket::event(event); +} + +bool QWebSocket_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QWebSocket_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QWebSocket::eventFilter(watched, event); +} + +bool QWebSocket_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QWebSocket_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QWebSocket::timerEvent(event); +} + +bool QWebSocket_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QWebSocket_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QWebSocket::childEvent(event); +} + +bool QWebSocket_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QWebSocket_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QWebSocket::customEvent(event); +} + +bool QWebSocket_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QWebSocket_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QWebSocket::connectNotify(*signal); +} + +bool QWebSocket_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QWebSocket_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QWebSocket::disconnectNotify(*signal); +} + +QObject* QWebSocket_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QWebSocket_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QWebSocket_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QWebSocket_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQWebSocket* self_cast = dynamic_cast( (QWebSocket*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QWebSocket_delete(QWebSocket* self) { + delete self; +} + diff --git a/qt6/websockets/gen_qwebsocket.go b/qt6/websockets/gen_qwebsocket.go new file mode 100644 index 000000000..a46fb5bce --- /dev/null +++ b/qt6/websockets/gen_qwebsocket.go @@ -0,0 +1,1124 @@ +package websockets + +/* + +#include "gen_qwebsocket.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "github.com/mappu/miqt/qt6/network" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QWebSocket struct { + h *C.QWebSocket + *qt6.QObject +} + +func (this *QWebSocket) cPointer() *C.QWebSocket { + if this == nil { + return nil + } + return this.h +} + +func (this *QWebSocket) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQWebSocket constructs the type using only CGO pointers. +func newQWebSocket(h *C.QWebSocket) *QWebSocket { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QWebSocket_virtbase(h, &outptr_QObject) + + return &QWebSocket{h: h, + QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQWebSocket constructs the type using only unsafe pointers. +func UnsafeNewQWebSocket(h unsafe.Pointer) *QWebSocket { + return newQWebSocket((*C.QWebSocket)(h)) +} + +// NewQWebSocket constructs a new QWebSocket object. +func NewQWebSocket() *QWebSocket { + + return newQWebSocket(C.QWebSocket_new()) +} + +// NewQWebSocket2 constructs a new QWebSocket object. +func NewQWebSocket2(origin string) *QWebSocket { + origin_ms := C.struct_miqt_string{} + origin_ms.data = C.CString(origin) + origin_ms.len = C.size_t(len(origin)) + defer C.free(unsafe.Pointer(origin_ms.data)) + + return newQWebSocket(C.QWebSocket_new2(origin_ms)) +} + +// NewQWebSocket3 constructs a new QWebSocket object. +func NewQWebSocket3(origin string, version QWebSocketProtocol__Version) *QWebSocket { + origin_ms := C.struct_miqt_string{} + origin_ms.data = C.CString(origin) + origin_ms.len = C.size_t(len(origin)) + defer C.free(unsafe.Pointer(origin_ms.data)) + + return newQWebSocket(C.QWebSocket_new3(origin_ms, (C.int)(version))) +} + +// NewQWebSocket4 constructs a new QWebSocket object. +func NewQWebSocket4(origin string, version QWebSocketProtocol__Version, parent *qt6.QObject) *QWebSocket { + origin_ms := C.struct_miqt_string{} + origin_ms.data = C.CString(origin) + origin_ms.len = C.size_t(len(origin)) + defer C.free(unsafe.Pointer(origin_ms.data)) + + return newQWebSocket(C.QWebSocket_new4(origin_ms, (C.int)(version), (*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QWebSocket) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QWebSocket_metaObject(this.h))) +} + +func (this *QWebSocket) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QWebSocket_metacast(this.h, param1_Cstring)) +} + +func QWebSocket_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QWebSocket_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) Abort() { + C.QWebSocket_abort(this.h) +} + +func (this *QWebSocket) Error() network.QAbstractSocket__SocketError { + return (network.QAbstractSocket__SocketError)(C.QWebSocket_error(this.h)) +} + +func (this *QWebSocket) ErrorString() string { + var _ms C.struct_miqt_string = C.QWebSocket_errorString(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) Flush() bool { + return (bool)(C.QWebSocket_flush(this.h)) +} + +func (this *QWebSocket) IsValid() bool { + return (bool)(C.QWebSocket_isValid(this.h)) +} + +func (this *QWebSocket) LocalAddress() *network.QHostAddress { + _goptr := network.UnsafeNewQHostAddress(unsafe.Pointer(C.QWebSocket_localAddress(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) LocalPort() uint16 { + return (uint16)(C.QWebSocket_localPort(this.h)) +} + +func (this *QWebSocket) PauseMode() network.QAbstractSocket__PauseMode { + return (network.QAbstractSocket__PauseMode)(C.QWebSocket_pauseMode(this.h)) +} + +func (this *QWebSocket) PeerAddress() *network.QHostAddress { + _goptr := network.UnsafeNewQHostAddress(unsafe.Pointer(C.QWebSocket_peerAddress(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) PeerName() string { + var _ms C.struct_miqt_string = C.QWebSocket_peerName(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) PeerPort() uint16 { + return (uint16)(C.QWebSocket_peerPort(this.h)) +} + +func (this *QWebSocket) Proxy() *network.QNetworkProxy { + _goptr := network.UnsafeNewQNetworkProxy(unsafe.Pointer(C.QWebSocket_proxy(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) SetProxy(networkProxy *network.QNetworkProxy) { + C.QWebSocket_setProxy(this.h, (*C.QNetworkProxy)(networkProxy.UnsafePointer())) +} + +func (this *QWebSocket) SetMaskGenerator(maskGenerator *QMaskGenerator) { + C.QWebSocket_setMaskGenerator(this.h, maskGenerator.cPointer()) +} + +func (this *QWebSocket) MaskGenerator() *QMaskGenerator { + return newQMaskGenerator(C.QWebSocket_maskGenerator(this.h)) +} + +func (this *QWebSocket) ReadBufferSize() int64 { + return (int64)(C.QWebSocket_readBufferSize(this.h)) +} + +func (this *QWebSocket) SetReadBufferSize(size int64) { + C.QWebSocket_setReadBufferSize(this.h, (C.longlong)(size)) +} + +func (this *QWebSocket) Resume() { + C.QWebSocket_resume(this.h) +} + +func (this *QWebSocket) SetPauseMode(pauseMode network.QAbstractSocket__PauseMode) { + C.QWebSocket_setPauseMode(this.h, (C.int)(pauseMode)) +} + +func (this *QWebSocket) State() network.QAbstractSocket__SocketState { + return (network.QAbstractSocket__SocketState)(C.QWebSocket_state(this.h)) +} + +func (this *QWebSocket) Version() QWebSocketProtocol__Version { + return (QWebSocketProtocol__Version)(C.QWebSocket_version(this.h)) +} + +func (this *QWebSocket) ResourceName() string { + var _ms C.struct_miqt_string = C.QWebSocket_resourceName(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) RequestUrl() *qt6.QUrl { + _goptr := qt6.UnsafeNewQUrl(unsafe.Pointer(C.QWebSocket_requestUrl(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) Request() *network.QNetworkRequest { + _goptr := network.UnsafeNewQNetworkRequest(unsafe.Pointer(C.QWebSocket_request(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) HandshakeOptions() *QWebSocketHandshakeOptions { + _goptr := newQWebSocketHandshakeOptions(C.QWebSocket_handshakeOptions(this.h)) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) Origin() string { + var _ms C.struct_miqt_string = C.QWebSocket_origin(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) Subprotocol() string { + var _ms C.struct_miqt_string = C.QWebSocket_subprotocol(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) CloseCode() QWebSocketProtocol__CloseCode { + return (QWebSocketProtocol__CloseCode)(C.QWebSocket_closeCode(this.h)) +} + +func (this *QWebSocket) CloseReason() string { + var _ms C.struct_miqt_string = C.QWebSocket_closeReason(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocket) SendTextMessage(message string) int64 { + message_ms := C.struct_miqt_string{} + message_ms.data = C.CString(message) + message_ms.len = C.size_t(len(message)) + defer C.free(unsafe.Pointer(message_ms.data)) + return (int64)(C.QWebSocket_sendTextMessage(this.h, message_ms)) +} + +func (this *QWebSocket) SendBinaryMessage(data []byte) int64 { + data_alias := C.struct_miqt_string{} + if len(data) > 0 { + data_alias.data = (*C.char)(unsafe.Pointer(&data[0])) + } else { + data_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + data_alias.len = C.size_t(len(data)) + return (int64)(C.QWebSocket_sendBinaryMessage(this.h, data_alias)) +} + +func (this *QWebSocket) IgnoreSslErrors(errors []network.QSslError) { + errors_CArray := (*[0xffff]*C.QSslError)(C.malloc(C.size_t(8 * len(errors)))) + defer C.free(unsafe.Pointer(errors_CArray)) + for i := range errors { + errors_CArray[i] = (*C.QSslError)(errors[i].UnsafePointer()) + } + errors_ma := C.struct_miqt_array{len: C.size_t(len(errors)), data: unsafe.Pointer(errors_CArray)} + C.QWebSocket_ignoreSslErrors(this.h, errors_ma) +} + +func (this *QWebSocket) ContinueInterruptedHandshake() { + C.QWebSocket_continueInterruptedHandshake(this.h) +} + +func (this *QWebSocket) SetSslConfiguration(sslConfiguration *network.QSslConfiguration) { + C.QWebSocket_setSslConfiguration(this.h, (*C.QSslConfiguration)(sslConfiguration.UnsafePointer())) +} + +func (this *QWebSocket) SslConfiguration() *network.QSslConfiguration { + _goptr := network.UnsafeNewQSslConfiguration(unsafe.Pointer(C.QWebSocket_sslConfiguration(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocket) BytesToWrite() int64 { + return (int64)(C.QWebSocket_bytesToWrite(this.h)) +} + +func (this *QWebSocket) SetMaxAllowedIncomingFrameSize(maxAllowedIncomingFrameSize uint64) { + C.QWebSocket_setMaxAllowedIncomingFrameSize(this.h, (C.ulonglong)(maxAllowedIncomingFrameSize)) +} + +func (this *QWebSocket) MaxAllowedIncomingFrameSize() uint64 { + return (uint64)(C.QWebSocket_maxAllowedIncomingFrameSize(this.h)) +} + +func (this *QWebSocket) SetMaxAllowedIncomingMessageSize(maxAllowedIncomingMessageSize uint64) { + C.QWebSocket_setMaxAllowedIncomingMessageSize(this.h, (C.ulonglong)(maxAllowedIncomingMessageSize)) +} + +func (this *QWebSocket) MaxAllowedIncomingMessageSize() uint64 { + return (uint64)(C.QWebSocket_maxAllowedIncomingMessageSize(this.h)) +} + +func QWebSocket_MaxIncomingMessageSize() uint64 { + return (uint64)(C.QWebSocket_maxIncomingMessageSize()) +} + +func QWebSocket_MaxIncomingFrameSize() uint64 { + return (uint64)(C.QWebSocket_maxIncomingFrameSize()) +} + +func (this *QWebSocket) SetOutgoingFrameSize(outgoingFrameSize uint64) { + C.QWebSocket_setOutgoingFrameSize(this.h, (C.ulonglong)(outgoingFrameSize)) +} + +func (this *QWebSocket) OutgoingFrameSize() uint64 { + return (uint64)(C.QWebSocket_outgoingFrameSize(this.h)) +} + +func QWebSocket_MaxOutgoingFrameSize() uint64 { + return (uint64)(C.QWebSocket_maxOutgoingFrameSize()) +} + +func (this *QWebSocket) Close() { + C.QWebSocket_close(this.h) +} + +func (this *QWebSocket) Open(url *qt6.QUrl) { + C.QWebSocket_open(this.h, (*C.QUrl)(url.UnsafePointer())) +} + +func (this *QWebSocket) OpenWithRequest(request *network.QNetworkRequest) { + C.QWebSocket_openWithRequest(this.h, (*C.QNetworkRequest)(request.UnsafePointer())) +} + +func (this *QWebSocket) Open2(url *qt6.QUrl, options *QWebSocketHandshakeOptions) { + C.QWebSocket_open2(this.h, (*C.QUrl)(url.UnsafePointer()), options.cPointer()) +} + +func (this *QWebSocket) Open3(request *network.QNetworkRequest, options *QWebSocketHandshakeOptions) { + C.QWebSocket_open3(this.h, (*C.QNetworkRequest)(request.UnsafePointer()), options.cPointer()) +} + +func (this *QWebSocket) Ping() { + C.QWebSocket_ping(this.h) +} + +func (this *QWebSocket) IgnoreSslErrors2() { + C.QWebSocket_ignoreSslErrors2(this.h) +} + +func (this *QWebSocket) AboutToClose() { + C.QWebSocket_aboutToClose(this.h) +} +func (this *QWebSocket) OnAboutToClose(slot func()) { + C.QWebSocket_connect_aboutToClose(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_aboutToClose +func miqt_exec_callback_QWebSocket_aboutToClose(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 *QWebSocket) Connected() { + C.QWebSocket_connected(this.h) +} +func (this *QWebSocket) OnConnected(slot func()) { + C.QWebSocket_connect_connected(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_connected +func miqt_exec_callback_QWebSocket_connected(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 *QWebSocket) Disconnected() { + C.QWebSocket_disconnected(this.h) +} +func (this *QWebSocket) OnDisconnected(slot func()) { + C.QWebSocket_connect_disconnected(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_disconnected +func miqt_exec_callback_QWebSocket_disconnected(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 *QWebSocket) StateChanged(state network.QAbstractSocket__SocketState) { + C.QWebSocket_stateChanged(this.h, (C.int)(state)) +} +func (this *QWebSocket) OnStateChanged(slot func(state network.QAbstractSocket__SocketState)) { + C.QWebSocket_connect_stateChanged(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_stateChanged +func miqt_exec_callback_QWebSocket_stateChanged(cb C.intptr_t, state C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(state network.QAbstractSocket__SocketState)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (network.QAbstractSocket__SocketState)(state) + + gofunc(slotval1) +} + +func (this *QWebSocket) ProxyAuthenticationRequired(proxy *network.QNetworkProxy, pAuthenticator *network.QAuthenticator) { + C.QWebSocket_proxyAuthenticationRequired(this.h, (*C.QNetworkProxy)(proxy.UnsafePointer()), (*C.QAuthenticator)(pAuthenticator.UnsafePointer())) +} +func (this *QWebSocket) OnProxyAuthenticationRequired(slot func(proxy *network.QNetworkProxy, pAuthenticator *network.QAuthenticator)) { + C.QWebSocket_connect_proxyAuthenticationRequired(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_proxyAuthenticationRequired +func miqt_exec_callback_QWebSocket_proxyAuthenticationRequired(cb C.intptr_t, proxy *C.QNetworkProxy, pAuthenticator *C.QAuthenticator) { + gofunc, ok := cgo.Handle(cb).Value().(func(proxy *network.QNetworkProxy, pAuthenticator *network.QAuthenticator)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := network.UnsafeNewQNetworkProxy(unsafe.Pointer(proxy)) + + slotval2 := network.UnsafeNewQAuthenticator(unsafe.Pointer(pAuthenticator)) + + gofunc(slotval1, slotval2) +} + +func (this *QWebSocket) ReadChannelFinished() { + C.QWebSocket_readChannelFinished(this.h) +} +func (this *QWebSocket) OnReadChannelFinished(slot func()) { + C.QWebSocket_connect_readChannelFinished(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_readChannelFinished +func miqt_exec_callback_QWebSocket_readChannelFinished(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 *QWebSocket) TextFrameReceived(frame string, isLastFrame bool) { + frame_ms := C.struct_miqt_string{} + frame_ms.data = C.CString(frame) + frame_ms.len = C.size_t(len(frame)) + defer C.free(unsafe.Pointer(frame_ms.data)) + C.QWebSocket_textFrameReceived(this.h, frame_ms, (C.bool)(isLastFrame)) +} +func (this *QWebSocket) OnTextFrameReceived(slot func(frame string, isLastFrame bool)) { + C.QWebSocket_connect_textFrameReceived(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_textFrameReceived +func miqt_exec_callback_QWebSocket_textFrameReceived(cb C.intptr_t, frame C.struct_miqt_string, isLastFrame C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(frame string, isLastFrame bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var frame_ms C.struct_miqt_string = frame + frame_ret := C.GoStringN(frame_ms.data, C.int(int64(frame_ms.len))) + C.free(unsafe.Pointer(frame_ms.data)) + slotval1 := frame_ret + slotval2 := (bool)(isLastFrame) + + gofunc(slotval1, slotval2) +} + +func (this *QWebSocket) BinaryFrameReceived(frame []byte, isLastFrame bool) { + frame_alias := C.struct_miqt_string{} + if len(frame) > 0 { + frame_alias.data = (*C.char)(unsafe.Pointer(&frame[0])) + } else { + frame_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + frame_alias.len = C.size_t(len(frame)) + C.QWebSocket_binaryFrameReceived(this.h, frame_alias, (C.bool)(isLastFrame)) +} +func (this *QWebSocket) OnBinaryFrameReceived(slot func(frame []byte, isLastFrame bool)) { + C.QWebSocket_connect_binaryFrameReceived(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_binaryFrameReceived +func miqt_exec_callback_QWebSocket_binaryFrameReceived(cb C.intptr_t, frame C.struct_miqt_string, isLastFrame C.bool) { + gofunc, ok := cgo.Handle(cb).Value().(func(frame []byte, isLastFrame bool)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var frame_bytearray C.struct_miqt_string = frame + frame_ret := C.GoBytes(unsafe.Pointer(frame_bytearray.data), C.int(int64(frame_bytearray.len))) + C.free(unsafe.Pointer(frame_bytearray.data)) + slotval1 := frame_ret + slotval2 := (bool)(isLastFrame) + + gofunc(slotval1, slotval2) +} + +func (this *QWebSocket) TextMessageReceived(message string) { + message_ms := C.struct_miqt_string{} + message_ms.data = C.CString(message) + message_ms.len = C.size_t(len(message)) + defer C.free(unsafe.Pointer(message_ms.data)) + C.QWebSocket_textMessageReceived(this.h, message_ms) +} +func (this *QWebSocket) OnTextMessageReceived(slot func(message string)) { + C.QWebSocket_connect_textMessageReceived(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_textMessageReceived +func miqt_exec_callback_QWebSocket_textMessageReceived(cb C.intptr_t, message C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(message string)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var message_ms C.struct_miqt_string = message + message_ret := C.GoStringN(message_ms.data, C.int(int64(message_ms.len))) + C.free(unsafe.Pointer(message_ms.data)) + slotval1 := message_ret + + gofunc(slotval1) +} + +func (this *QWebSocket) BinaryMessageReceived(message []byte) { + message_alias := C.struct_miqt_string{} + if len(message) > 0 { + message_alias.data = (*C.char)(unsafe.Pointer(&message[0])) + } else { + message_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + message_alias.len = C.size_t(len(message)) + C.QWebSocket_binaryMessageReceived(this.h, message_alias) +} +func (this *QWebSocket) OnBinaryMessageReceived(slot func(message []byte)) { + C.QWebSocket_connect_binaryMessageReceived(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_binaryMessageReceived +func miqt_exec_callback_QWebSocket_binaryMessageReceived(cb C.intptr_t, message C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(message []byte)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var message_bytearray C.struct_miqt_string = message + message_ret := C.GoBytes(unsafe.Pointer(message_bytearray.data), C.int(int64(message_bytearray.len))) + C.free(unsafe.Pointer(message_bytearray.data)) + slotval1 := message_ret + + gofunc(slotval1) +} + +func (this *QWebSocket) ErrorWithError(error network.QAbstractSocket__SocketError) { + C.QWebSocket_errorWithError(this.h, (C.int)(error)) +} +func (this *QWebSocket) OnErrorWithError(slot func(error network.QAbstractSocket__SocketError)) { + C.QWebSocket_connect_errorWithError(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_errorWithError +func miqt_exec_callback_QWebSocket_errorWithError(cb C.intptr_t, error C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(error network.QAbstractSocket__SocketError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (network.QAbstractSocket__SocketError)(error) + + gofunc(slotval1) +} + +func (this *QWebSocket) Pong(elapsedTime uint64, payload []byte) { + payload_alias := C.struct_miqt_string{} + if len(payload) > 0 { + payload_alias.data = (*C.char)(unsafe.Pointer(&payload[0])) + } else { + payload_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + payload_alias.len = C.size_t(len(payload)) + C.QWebSocket_pong(this.h, (C.ulonglong)(elapsedTime), payload_alias) +} +func (this *QWebSocket) OnPong(slot func(elapsedTime uint64, payload []byte)) { + C.QWebSocket_connect_pong(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_pong +func miqt_exec_callback_QWebSocket_pong(cb C.intptr_t, elapsedTime C.ulonglong, payload C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(elapsedTime uint64, payload []byte)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (uint64)(elapsedTime) + + var payload_bytearray C.struct_miqt_string = payload + payload_ret := C.GoBytes(unsafe.Pointer(payload_bytearray.data), C.int(int64(payload_bytearray.len))) + C.free(unsafe.Pointer(payload_bytearray.data)) + slotval2 := payload_ret + + gofunc(slotval1, slotval2) +} + +func (this *QWebSocket) BytesWritten(bytes int64) { + C.QWebSocket_bytesWritten(this.h, (C.longlong)(bytes)) +} +func (this *QWebSocket) OnBytesWritten(slot func(bytes int64)) { + C.QWebSocket_connect_bytesWritten(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_bytesWritten +func miqt_exec_callback_QWebSocket_bytesWritten(cb C.intptr_t, bytes C.longlong) { + gofunc, ok := cgo.Handle(cb).Value().(func(bytes int64)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (int64)(bytes) + + gofunc(slotval1) +} + +func (this *QWebSocket) PeerVerifyError(error *network.QSslError) { + C.QWebSocket_peerVerifyError(this.h, (*C.QSslError)(error.UnsafePointer())) +} +func (this *QWebSocket) OnPeerVerifyError(slot func(error *network.QSslError)) { + C.QWebSocket_connect_peerVerifyError(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_peerVerifyError +func miqt_exec_callback_QWebSocket_peerVerifyError(cb C.intptr_t, error *C.QSslError) { + gofunc, ok := cgo.Handle(cb).Value().(func(error *network.QSslError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := network.UnsafeNewQSslError(unsafe.Pointer(error)) + + gofunc(slotval1) +} + +func (this *QWebSocket) SslErrors(errors []network.QSslError) { + errors_CArray := (*[0xffff]*C.QSslError)(C.malloc(C.size_t(8 * len(errors)))) + defer C.free(unsafe.Pointer(errors_CArray)) + for i := range errors { + errors_CArray[i] = (*C.QSslError)(errors[i].UnsafePointer()) + } + errors_ma := C.struct_miqt_array{len: C.size_t(len(errors)), data: unsafe.Pointer(errors_CArray)} + C.QWebSocket_sslErrors(this.h, errors_ma) +} +func (this *QWebSocket) OnSslErrors(slot func(errors []network.QSslError)) { + C.QWebSocket_connect_sslErrors(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_sslErrors +func miqt_exec_callback_QWebSocket_sslErrors(cb C.intptr_t, errors C.struct_miqt_array) { + gofunc, ok := cgo.Handle(cb).Value().(func(errors []network.QSslError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var errors_ma C.struct_miqt_array = errors + errors_ret := make([]network.QSslError, int(errors_ma.len)) + errors_outCast := (*[0xffff]*C.QSslError)(unsafe.Pointer(errors_ma.data)) // hey ya + for i := 0; i < int(errors_ma.len); i++ { + errors_lv_goptr := network.UnsafeNewQSslError(unsafe.Pointer(errors_outCast[i])) + errors_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + errors_ret[i] = *errors_lv_goptr + } + slotval1 := errors_ret + + gofunc(slotval1) +} + +func (this *QWebSocket) PreSharedKeyAuthenticationRequired(authenticator *network.QSslPreSharedKeyAuthenticator) { + C.QWebSocket_preSharedKeyAuthenticationRequired(this.h, (*C.QSslPreSharedKeyAuthenticator)(authenticator.UnsafePointer())) +} +func (this *QWebSocket) OnPreSharedKeyAuthenticationRequired(slot func(authenticator *network.QSslPreSharedKeyAuthenticator)) { + C.QWebSocket_connect_preSharedKeyAuthenticationRequired(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_preSharedKeyAuthenticationRequired +func miqt_exec_callback_QWebSocket_preSharedKeyAuthenticationRequired(cb C.intptr_t, authenticator *C.QSslPreSharedKeyAuthenticator) { + gofunc, ok := cgo.Handle(cb).Value().(func(authenticator *network.QSslPreSharedKeyAuthenticator)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := network.UnsafeNewQSslPreSharedKeyAuthenticator(unsafe.Pointer(authenticator)) + + gofunc(slotval1) +} + +func (this *QWebSocket) AlertSent(level network.QSsl__AlertLevel, typeVal network.QSsl__AlertType, description string) { + description_ms := C.struct_miqt_string{} + description_ms.data = C.CString(description) + description_ms.len = C.size_t(len(description)) + defer C.free(unsafe.Pointer(description_ms.data)) + C.QWebSocket_alertSent(this.h, (C.int)(level), (C.int)(typeVal), description_ms) +} +func (this *QWebSocket) OnAlertSent(slot func(level network.QSsl__AlertLevel, typeVal network.QSsl__AlertType, description string)) { + C.QWebSocket_connect_alertSent(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_alertSent +func miqt_exec_callback_QWebSocket_alertSent(cb C.intptr_t, level C.int, typeVal C.int, description C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(level network.QSsl__AlertLevel, typeVal network.QSsl__AlertType, description string)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (network.QSsl__AlertLevel)(level) + + slotval2 := (network.QSsl__AlertType)(typeVal) + + var description_ms C.struct_miqt_string = description + description_ret := C.GoStringN(description_ms.data, C.int(int64(description_ms.len))) + C.free(unsafe.Pointer(description_ms.data)) + slotval3 := description_ret + + gofunc(slotval1, slotval2, slotval3) +} + +func (this *QWebSocket) AlertReceived(level network.QSsl__AlertLevel, typeVal network.QSsl__AlertType, description string) { + description_ms := C.struct_miqt_string{} + description_ms.data = C.CString(description) + description_ms.len = C.size_t(len(description)) + defer C.free(unsafe.Pointer(description_ms.data)) + C.QWebSocket_alertReceived(this.h, (C.int)(level), (C.int)(typeVal), description_ms) +} +func (this *QWebSocket) OnAlertReceived(slot func(level network.QSsl__AlertLevel, typeVal network.QSsl__AlertType, description string)) { + C.QWebSocket_connect_alertReceived(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_alertReceived +func miqt_exec_callback_QWebSocket_alertReceived(cb C.intptr_t, level C.int, typeVal C.int, description C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(level network.QSsl__AlertLevel, typeVal network.QSsl__AlertType, description string)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (network.QSsl__AlertLevel)(level) + + slotval2 := (network.QSsl__AlertType)(typeVal) + + var description_ms C.struct_miqt_string = description + description_ret := C.GoStringN(description_ms.data, C.int(int64(description_ms.len))) + C.free(unsafe.Pointer(description_ms.data)) + slotval3 := description_ret + + gofunc(slotval1, slotval2, slotval3) +} + +func (this *QWebSocket) HandshakeInterruptedOnError(error *network.QSslError) { + C.QWebSocket_handshakeInterruptedOnError(this.h, (*C.QSslError)(error.UnsafePointer())) +} +func (this *QWebSocket) OnHandshakeInterruptedOnError(slot func(error *network.QSslError)) { + C.QWebSocket_connect_handshakeInterruptedOnError(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocket_handshakeInterruptedOnError +func miqt_exec_callback_QWebSocket_handshakeInterruptedOnError(cb C.intptr_t, error *C.QSslError) { + gofunc, ok := cgo.Handle(cb).Value().(func(error *network.QSslError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := network.UnsafeNewQSslError(unsafe.Pointer(error)) + + gofunc(slotval1) +} + +func QWebSocket_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.QWebSocket_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QWebSocket_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.QWebSocket_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 *QWebSocket) CloseWithCloseCode(closeCode QWebSocketProtocol__CloseCode) { + C.QWebSocket_closeWithCloseCode(this.h, (C.int)(closeCode)) +} + +func (this *QWebSocket) Close2(closeCode QWebSocketProtocol__CloseCode, reason string) { + reason_ms := C.struct_miqt_string{} + reason_ms.data = C.CString(reason) + reason_ms.len = C.size_t(len(reason)) + defer C.free(unsafe.Pointer(reason_ms.data)) + C.QWebSocket_close2(this.h, (C.int)(closeCode), reason_ms) +} + +func (this *QWebSocket) PingWithPayload(payload []byte) { + payload_alias := C.struct_miqt_string{} + if len(payload) > 0 { + payload_alias.data = (*C.char)(unsafe.Pointer(&payload[0])) + } else { + payload_alias.data = (*C.char)(unsafe.Pointer(nil)) + } + payload_alias.len = C.size_t(len(payload)) + C.QWebSocket_pingWithPayload(this.h, payload_alias) +} + +// Sender can only be called from a QWebSocket that was directly constructed. +func (this *QWebSocket) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QWebSocket_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 QWebSocket that was directly constructed. +func (this *QWebSocket) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QWebSocket_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 QWebSocket that was directly constructed. +func (this *QWebSocket) 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.QWebSocket_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 QWebSocket that was directly constructed. +func (this *QWebSocket) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QWebSocket_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 *QWebSocket) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QWebSocket_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QWebSocket) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QWebSocket_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_QWebSocket_event +func miqt_exec_callback_QWebSocket_event(self *C.QWebSocket, 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((&QWebSocket{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QWebSocket) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QWebSocket_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QWebSocket) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QWebSocket_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_QWebSocket_eventFilter +func miqt_exec_callback_QWebSocket_eventFilter(self *C.QWebSocket, 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((&QWebSocket{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QWebSocket) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QWebSocket_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QWebSocket) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QWebSocket_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_QWebSocket_timerEvent +func miqt_exec_callback_QWebSocket_timerEvent(self *C.QWebSocket, 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((&QWebSocket{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QWebSocket) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QWebSocket_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QWebSocket) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QWebSocket_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_QWebSocket_childEvent +func miqt_exec_callback_QWebSocket_childEvent(self *C.QWebSocket, 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((&QWebSocket{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QWebSocket) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QWebSocket_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QWebSocket) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QWebSocket_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_QWebSocket_customEvent +func miqt_exec_callback_QWebSocket_customEvent(self *C.QWebSocket, 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((&QWebSocket{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QWebSocket) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QWebSocket_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QWebSocket) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QWebSocket_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_QWebSocket_connectNotify +func miqt_exec_callback_QWebSocket_connectNotify(self *C.QWebSocket, 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((&QWebSocket{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QWebSocket) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QWebSocket_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QWebSocket) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QWebSocket_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_QWebSocket_disconnectNotify +func miqt_exec_callback_QWebSocket_disconnectNotify(self *C.QWebSocket, 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((&QWebSocket{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QWebSocket) Delete() { + C.QWebSocket_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 *QWebSocket) GoGC() { + runtime.SetFinalizer(this, func(this *QWebSocket) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/websockets/gen_qwebsocket.h b/qt6/websockets/gen_qwebsocket.h new file mode 100644 index 000000000..0beb96cc5 --- /dev/null +++ b/qt6/websockets/gen_qwebsocket.h @@ -0,0 +1,185 @@ +#pragma once +#ifndef MIQT_QT6_WEBSOCKETS_GEN_QWEBSOCKET_H +#define MIQT_QT6_WEBSOCKETS_GEN_QWEBSOCKET_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QAuthenticator; +class QChildEvent; +class QEvent; +class QHostAddress; +class QMaskGenerator; +class QMetaMethod; +class QMetaObject; +class QNetworkProxy; +class QNetworkRequest; +class QObject; +class QSslConfiguration; +class QSslError; +class QSslPreSharedKeyAuthenticator; +class QTimerEvent; +class QUrl; +class QWebSocket; +class QWebSocketHandshakeOptions; +#else +typedef struct QAuthenticator QAuthenticator; +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QHostAddress QHostAddress; +typedef struct QMaskGenerator QMaskGenerator; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QNetworkProxy QNetworkProxy; +typedef struct QNetworkRequest QNetworkRequest; +typedef struct QObject QObject; +typedef struct QSslConfiguration QSslConfiguration; +typedef struct QSslError QSslError; +typedef struct QSslPreSharedKeyAuthenticator QSslPreSharedKeyAuthenticator; +typedef struct QTimerEvent QTimerEvent; +typedef struct QUrl QUrl; +typedef struct QWebSocket QWebSocket; +typedef struct QWebSocketHandshakeOptions QWebSocketHandshakeOptions; +#endif + +QWebSocket* QWebSocket_new(); +QWebSocket* QWebSocket_new2(struct miqt_string origin); +QWebSocket* QWebSocket_new3(struct miqt_string origin, int version); +QWebSocket* QWebSocket_new4(struct miqt_string origin, int version, QObject* parent); +void QWebSocket_virtbase(QWebSocket* src, QObject** outptr_QObject); +QMetaObject* QWebSocket_metaObject(const QWebSocket* self); +void* QWebSocket_metacast(QWebSocket* self, const char* param1); +struct miqt_string QWebSocket_tr(const char* s); +void QWebSocket_abort(QWebSocket* self); +int QWebSocket_error(const QWebSocket* self); +struct miqt_string QWebSocket_errorString(const QWebSocket* self); +bool QWebSocket_flush(QWebSocket* self); +bool QWebSocket_isValid(const QWebSocket* self); +QHostAddress* QWebSocket_localAddress(const QWebSocket* self); +unsigned short QWebSocket_localPort(const QWebSocket* self); +int QWebSocket_pauseMode(const QWebSocket* self); +QHostAddress* QWebSocket_peerAddress(const QWebSocket* self); +struct miqt_string QWebSocket_peerName(const QWebSocket* self); +unsigned short QWebSocket_peerPort(const QWebSocket* self); +QNetworkProxy* QWebSocket_proxy(const QWebSocket* self); +void QWebSocket_setProxy(QWebSocket* self, QNetworkProxy* networkProxy); +void QWebSocket_setMaskGenerator(QWebSocket* self, QMaskGenerator* maskGenerator); +QMaskGenerator* QWebSocket_maskGenerator(const QWebSocket* self); +long long QWebSocket_readBufferSize(const QWebSocket* self); +void QWebSocket_setReadBufferSize(QWebSocket* self, long long size); +void QWebSocket_resume(QWebSocket* self); +void QWebSocket_setPauseMode(QWebSocket* self, int pauseMode); +int QWebSocket_state(const QWebSocket* self); +int QWebSocket_version(const QWebSocket* self); +struct miqt_string QWebSocket_resourceName(const QWebSocket* self); +QUrl* QWebSocket_requestUrl(const QWebSocket* self); +QNetworkRequest* QWebSocket_request(const QWebSocket* self); +QWebSocketHandshakeOptions* QWebSocket_handshakeOptions(const QWebSocket* self); +struct miqt_string QWebSocket_origin(const QWebSocket* self); +struct miqt_string QWebSocket_subprotocol(const QWebSocket* self); +int QWebSocket_closeCode(const QWebSocket* self); +struct miqt_string QWebSocket_closeReason(const QWebSocket* self); +long long QWebSocket_sendTextMessage(QWebSocket* self, struct miqt_string message); +long long QWebSocket_sendBinaryMessage(QWebSocket* self, struct miqt_string data); +void QWebSocket_ignoreSslErrors(QWebSocket* self, struct miqt_array /* of QSslError* */ errors); +void QWebSocket_continueInterruptedHandshake(QWebSocket* self); +void QWebSocket_setSslConfiguration(QWebSocket* self, QSslConfiguration* sslConfiguration); +QSslConfiguration* QWebSocket_sslConfiguration(const QWebSocket* self); +long long QWebSocket_bytesToWrite(const QWebSocket* self); +void QWebSocket_setMaxAllowedIncomingFrameSize(QWebSocket* self, unsigned long long maxAllowedIncomingFrameSize); +unsigned long long QWebSocket_maxAllowedIncomingFrameSize(const QWebSocket* self); +void QWebSocket_setMaxAllowedIncomingMessageSize(QWebSocket* self, unsigned long long maxAllowedIncomingMessageSize); +unsigned long long QWebSocket_maxAllowedIncomingMessageSize(const QWebSocket* self); +unsigned long long QWebSocket_maxIncomingMessageSize(); +unsigned long long QWebSocket_maxIncomingFrameSize(); +void QWebSocket_setOutgoingFrameSize(QWebSocket* self, unsigned long long outgoingFrameSize); +unsigned long long QWebSocket_outgoingFrameSize(const QWebSocket* self); +unsigned long long QWebSocket_maxOutgoingFrameSize(); +void QWebSocket_close(QWebSocket* self); +void QWebSocket_open(QWebSocket* self, QUrl* url); +void QWebSocket_openWithRequest(QWebSocket* self, QNetworkRequest* request); +void QWebSocket_open2(QWebSocket* self, QUrl* url, QWebSocketHandshakeOptions* options); +void QWebSocket_open3(QWebSocket* self, QNetworkRequest* request, QWebSocketHandshakeOptions* options); +void QWebSocket_ping(QWebSocket* self); +void QWebSocket_ignoreSslErrors2(QWebSocket* self); +void QWebSocket_aboutToClose(QWebSocket* self); +void QWebSocket_connect_aboutToClose(QWebSocket* self, intptr_t slot); +void QWebSocket_connected(QWebSocket* self); +void QWebSocket_connect_connected(QWebSocket* self, intptr_t slot); +void QWebSocket_disconnected(QWebSocket* self); +void QWebSocket_connect_disconnected(QWebSocket* self, intptr_t slot); +void QWebSocket_stateChanged(QWebSocket* self, int state); +void QWebSocket_connect_stateChanged(QWebSocket* self, intptr_t slot); +void QWebSocket_proxyAuthenticationRequired(QWebSocket* self, QNetworkProxy* proxy, QAuthenticator* pAuthenticator); +void QWebSocket_connect_proxyAuthenticationRequired(QWebSocket* self, intptr_t slot); +void QWebSocket_readChannelFinished(QWebSocket* self); +void QWebSocket_connect_readChannelFinished(QWebSocket* self, intptr_t slot); +void QWebSocket_textFrameReceived(QWebSocket* self, struct miqt_string frame, bool isLastFrame); +void QWebSocket_connect_textFrameReceived(QWebSocket* self, intptr_t slot); +void QWebSocket_binaryFrameReceived(QWebSocket* self, struct miqt_string frame, bool isLastFrame); +void QWebSocket_connect_binaryFrameReceived(QWebSocket* self, intptr_t slot); +void QWebSocket_textMessageReceived(QWebSocket* self, struct miqt_string message); +void QWebSocket_connect_textMessageReceived(QWebSocket* self, intptr_t slot); +void QWebSocket_binaryMessageReceived(QWebSocket* self, struct miqt_string message); +void QWebSocket_connect_binaryMessageReceived(QWebSocket* self, intptr_t slot); +void QWebSocket_errorWithError(QWebSocket* self, int error); +void QWebSocket_connect_errorWithError(QWebSocket* self, intptr_t slot); +void QWebSocket_pong(QWebSocket* self, unsigned long long elapsedTime, struct miqt_string payload); +void QWebSocket_connect_pong(QWebSocket* self, intptr_t slot); +void QWebSocket_bytesWritten(QWebSocket* self, long long bytes); +void QWebSocket_connect_bytesWritten(QWebSocket* self, intptr_t slot); +void QWebSocket_peerVerifyError(QWebSocket* self, QSslError* error); +void QWebSocket_connect_peerVerifyError(QWebSocket* self, intptr_t slot); +void QWebSocket_sslErrors(QWebSocket* self, struct miqt_array /* of QSslError* */ errors); +void QWebSocket_connect_sslErrors(QWebSocket* self, intptr_t slot); +void QWebSocket_preSharedKeyAuthenticationRequired(QWebSocket* self, QSslPreSharedKeyAuthenticator* authenticator); +void QWebSocket_connect_preSharedKeyAuthenticationRequired(QWebSocket* self, intptr_t slot); +void QWebSocket_alertSent(QWebSocket* self, int level, int type, struct miqt_string description); +void QWebSocket_connect_alertSent(QWebSocket* self, intptr_t slot); +void QWebSocket_alertReceived(QWebSocket* self, int level, int type, struct miqt_string description); +void QWebSocket_connect_alertReceived(QWebSocket* self, intptr_t slot); +void QWebSocket_handshakeInterruptedOnError(QWebSocket* self, QSslError* error); +void QWebSocket_connect_handshakeInterruptedOnError(QWebSocket* self, intptr_t slot); +struct miqt_string QWebSocket_tr2(const char* s, const char* c); +struct miqt_string QWebSocket_tr3(const char* s, const char* c, int n); +void QWebSocket_closeWithCloseCode(QWebSocket* self, int closeCode); +void QWebSocket_close2(QWebSocket* self, int closeCode, struct miqt_string reason); +void QWebSocket_pingWithPayload(QWebSocket* self, struct miqt_string payload); + +bool QWebSocket_override_virtual_event(void* self, intptr_t slot); +bool QWebSocket_virtualbase_event(void* self, QEvent* event); +bool QWebSocket_override_virtual_eventFilter(void* self, intptr_t slot); +bool QWebSocket_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QWebSocket_override_virtual_timerEvent(void* self, intptr_t slot); +void QWebSocket_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QWebSocket_override_virtual_childEvent(void* self, intptr_t slot); +void QWebSocket_virtualbase_childEvent(void* self, QChildEvent* event); +bool QWebSocket_override_virtual_customEvent(void* self, intptr_t slot); +void QWebSocket_virtualbase_customEvent(void* self, QEvent* event); +bool QWebSocket_override_virtual_connectNotify(void* self, intptr_t slot); +void QWebSocket_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QWebSocket_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QWebSocket_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QWebSocket_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QWebSocket_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QWebSocket_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QWebSocket_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QWebSocket_delete(QWebSocket* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/websockets/gen_qwebsocketcorsauthenticator.cpp b/qt6/websockets/gen_qwebsocketcorsauthenticator.cpp new file mode 100644 index 000000000..7d22e9db7 --- /dev/null +++ b/qt6/websockets/gen_qwebsocketcorsauthenticator.cpp @@ -0,0 +1,55 @@ +#include +#include +#include +#include +#include +#include "gen_qwebsocketcorsauthenticator.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +QWebSocketCorsAuthenticator* QWebSocketCorsAuthenticator_new(struct miqt_string origin) { + QString origin_QString = QString::fromUtf8(origin.data, origin.len); + return new (std::nothrow) QWebSocketCorsAuthenticator(origin_QString); +} + +QWebSocketCorsAuthenticator* QWebSocketCorsAuthenticator_new2(QWebSocketCorsAuthenticator* other) { + return new (std::nothrow) QWebSocketCorsAuthenticator(*other); +} + +void QWebSocketCorsAuthenticator_swap(QWebSocketCorsAuthenticator* self, QWebSocketCorsAuthenticator* other) { + self->swap(*other); +} + +void QWebSocketCorsAuthenticator_operatorAssign(QWebSocketCorsAuthenticator* self, QWebSocketCorsAuthenticator* other) { + self->operator=(*other); +} + +struct miqt_string QWebSocketCorsAuthenticator_origin(const QWebSocketCorsAuthenticator* self) { + QString _ret = self->origin(); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +void QWebSocketCorsAuthenticator_setAllowed(QWebSocketCorsAuthenticator* self, bool allowed) { + self->setAllowed(allowed); +} + +bool QWebSocketCorsAuthenticator_allowed(const QWebSocketCorsAuthenticator* self) { + return self->allowed(); +} + +void QWebSocketCorsAuthenticator_delete(QWebSocketCorsAuthenticator* self) { + delete self; +} + diff --git a/qt6/websockets/gen_qwebsocketcorsauthenticator.go b/qt6/websockets/gen_qwebsocketcorsauthenticator.go new file mode 100644 index 000000000..f5760fb0d --- /dev/null +++ b/qt6/websockets/gen_qwebsocketcorsauthenticator.go @@ -0,0 +1,99 @@ +package websockets + +/* + +#include "gen_qwebsocketcorsauthenticator.h" +#include + +*/ +import "C" + +import ( + "runtime" + "unsafe" +) + +type QWebSocketCorsAuthenticator struct { + h *C.QWebSocketCorsAuthenticator +} + +func (this *QWebSocketCorsAuthenticator) cPointer() *C.QWebSocketCorsAuthenticator { + if this == nil { + return nil + } + return this.h +} + +func (this *QWebSocketCorsAuthenticator) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQWebSocketCorsAuthenticator constructs the type using only CGO pointers. +func newQWebSocketCorsAuthenticator(h *C.QWebSocketCorsAuthenticator) *QWebSocketCorsAuthenticator { + if h == nil { + return nil + } + + return &QWebSocketCorsAuthenticator{h: h} +} + +// UnsafeNewQWebSocketCorsAuthenticator constructs the type using only unsafe pointers. +func UnsafeNewQWebSocketCorsAuthenticator(h unsafe.Pointer) *QWebSocketCorsAuthenticator { + return newQWebSocketCorsAuthenticator((*C.QWebSocketCorsAuthenticator)(h)) +} + +// NewQWebSocketCorsAuthenticator constructs a new QWebSocketCorsAuthenticator object. +func NewQWebSocketCorsAuthenticator(origin string) *QWebSocketCorsAuthenticator { + origin_ms := C.struct_miqt_string{} + origin_ms.data = C.CString(origin) + origin_ms.len = C.size_t(len(origin)) + defer C.free(unsafe.Pointer(origin_ms.data)) + + return newQWebSocketCorsAuthenticator(C.QWebSocketCorsAuthenticator_new(origin_ms)) +} + +// NewQWebSocketCorsAuthenticator2 constructs a new QWebSocketCorsAuthenticator object. +func NewQWebSocketCorsAuthenticator2(other *QWebSocketCorsAuthenticator) *QWebSocketCorsAuthenticator { + + return newQWebSocketCorsAuthenticator(C.QWebSocketCorsAuthenticator_new2(other.cPointer())) +} + +func (this *QWebSocketCorsAuthenticator) Swap(other *QWebSocketCorsAuthenticator) { + C.QWebSocketCorsAuthenticator_swap(this.h, other.cPointer()) +} + +func (this *QWebSocketCorsAuthenticator) OperatorAssign(other *QWebSocketCorsAuthenticator) { + C.QWebSocketCorsAuthenticator_operatorAssign(this.h, other.cPointer()) +} + +func (this *QWebSocketCorsAuthenticator) Origin() string { + var _ms C.struct_miqt_string = C.QWebSocketCorsAuthenticator_origin(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocketCorsAuthenticator) SetAllowed(allowed bool) { + C.QWebSocketCorsAuthenticator_setAllowed(this.h, (C.bool)(allowed)) +} + +func (this *QWebSocketCorsAuthenticator) Allowed() bool { + return (bool)(C.QWebSocketCorsAuthenticator_allowed(this.h)) +} + +// Delete this object from C++ memory. +func (this *QWebSocketCorsAuthenticator) Delete() { + C.QWebSocketCorsAuthenticator_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 *QWebSocketCorsAuthenticator) GoGC() { + runtime.SetFinalizer(this, func(this *QWebSocketCorsAuthenticator) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/websockets/gen_qwebsocketcorsauthenticator.h b/qt6/websockets/gen_qwebsocketcorsauthenticator.h new file mode 100644 index 000000000..c8bf99b86 --- /dev/null +++ b/qt6/websockets/gen_qwebsocketcorsauthenticator.h @@ -0,0 +1,37 @@ +#pragma once +#ifndef MIQT_QT6_WEBSOCKETS_GEN_QWEBSOCKETCORSAUTHENTICATOR_H +#define MIQT_QT6_WEBSOCKETS_GEN_QWEBSOCKETCORSAUTHENTICATOR_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QWebSocketCorsAuthenticator; +#else +typedef struct QWebSocketCorsAuthenticator QWebSocketCorsAuthenticator; +#endif + +QWebSocketCorsAuthenticator* QWebSocketCorsAuthenticator_new(struct miqt_string origin); +QWebSocketCorsAuthenticator* QWebSocketCorsAuthenticator_new2(QWebSocketCorsAuthenticator* other); +void QWebSocketCorsAuthenticator_swap(QWebSocketCorsAuthenticator* self, QWebSocketCorsAuthenticator* other); +void QWebSocketCorsAuthenticator_operatorAssign(QWebSocketCorsAuthenticator* self, QWebSocketCorsAuthenticator* other); +struct miqt_string QWebSocketCorsAuthenticator_origin(const QWebSocketCorsAuthenticator* self); +void QWebSocketCorsAuthenticator_setAllowed(QWebSocketCorsAuthenticator* self, bool allowed); +bool QWebSocketCorsAuthenticator_allowed(const QWebSocketCorsAuthenticator* self); + +void QWebSocketCorsAuthenticator_delete(QWebSocketCorsAuthenticator* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/websockets/gen_qwebsockethandshakeoptions.cpp b/qt6/websockets/gen_qwebsockethandshakeoptions.cpp new file mode 100644 index 000000000..a9934afdc --- /dev/null +++ b/qt6/websockets/gen_qwebsockethandshakeoptions.cpp @@ -0,0 +1,67 @@ +#include +#include +#include +#include +#include +#include +#include "gen_qwebsockethandshakeoptions.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +QWebSocketHandshakeOptions* QWebSocketHandshakeOptions_new() { + return new (std::nothrow) QWebSocketHandshakeOptions(); +} + +QWebSocketHandshakeOptions* QWebSocketHandshakeOptions_new2(QWebSocketHandshakeOptions* other) { + return new (std::nothrow) QWebSocketHandshakeOptions(*other); +} + +void QWebSocketHandshakeOptions_operatorAssign(QWebSocketHandshakeOptions* self, QWebSocketHandshakeOptions* other) { + self->operator=(*other); +} + +void QWebSocketHandshakeOptions_swap(QWebSocketHandshakeOptions* self, QWebSocketHandshakeOptions* other) { + self->swap(*other); +} + +struct miqt_array /* of struct miqt_string */ QWebSocketHandshakeOptions_subprotocols(const QWebSocketHandshakeOptions* self) { + QStringList _ret = self->subprotocols(); + // Convert QList<> from C++ memory to manually-managed C memory + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QString _lv_ret = _ret[i]; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _lv_b = _lv_ret.toUtf8(); + struct miqt_string _lv_ms; + _lv_ms.len = _lv_b.length(); + _lv_ms.data = static_cast(malloc(_lv_ms.len)); + memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len); + _arr[i] = _lv_ms; + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +void QWebSocketHandshakeOptions_setSubprotocols(QWebSocketHandshakeOptions* self, struct miqt_array /* of struct miqt_string */ protocols) { + QStringList protocols_QList; + protocols_QList.reserve(protocols.len); + struct miqt_string* protocols_arr = static_cast(protocols.data); + for(size_t i = 0; i < protocols.len; ++i) { + QString protocols_arr_i_QString = QString::fromUtf8(protocols_arr[i].data, protocols_arr[i].len); + protocols_QList.push_back(protocols_arr_i_QString); + } + self->setSubprotocols(protocols_QList); +} + +void QWebSocketHandshakeOptions_delete(QWebSocketHandshakeOptions* self) { + delete self; +} + diff --git a/qt6/websockets/gen_qwebsockethandshakeoptions.go b/qt6/websockets/gen_qwebsockethandshakeoptions.go new file mode 100644 index 000000000..c509d252f --- /dev/null +++ b/qt6/websockets/gen_qwebsockethandshakeoptions.go @@ -0,0 +1,107 @@ +package websockets + +/* + +#include "gen_qwebsockethandshakeoptions.h" +#include + +*/ +import "C" + +import ( + "runtime" + "unsafe" +) + +type QWebSocketHandshakeOptions struct { + h *C.QWebSocketHandshakeOptions +} + +func (this *QWebSocketHandshakeOptions) cPointer() *C.QWebSocketHandshakeOptions { + if this == nil { + return nil + } + return this.h +} + +func (this *QWebSocketHandshakeOptions) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQWebSocketHandshakeOptions constructs the type using only CGO pointers. +func newQWebSocketHandshakeOptions(h *C.QWebSocketHandshakeOptions) *QWebSocketHandshakeOptions { + if h == nil { + return nil + } + + return &QWebSocketHandshakeOptions{h: h} +} + +// UnsafeNewQWebSocketHandshakeOptions constructs the type using only unsafe pointers. +func UnsafeNewQWebSocketHandshakeOptions(h unsafe.Pointer) *QWebSocketHandshakeOptions { + return newQWebSocketHandshakeOptions((*C.QWebSocketHandshakeOptions)(h)) +} + +// NewQWebSocketHandshakeOptions constructs a new QWebSocketHandshakeOptions object. +func NewQWebSocketHandshakeOptions() *QWebSocketHandshakeOptions { + + return newQWebSocketHandshakeOptions(C.QWebSocketHandshakeOptions_new()) +} + +// NewQWebSocketHandshakeOptions2 constructs a new QWebSocketHandshakeOptions object. +func NewQWebSocketHandshakeOptions2(other *QWebSocketHandshakeOptions) *QWebSocketHandshakeOptions { + + return newQWebSocketHandshakeOptions(C.QWebSocketHandshakeOptions_new2(other.cPointer())) +} + +func (this *QWebSocketHandshakeOptions) OperatorAssign(other *QWebSocketHandshakeOptions) { + C.QWebSocketHandshakeOptions_operatorAssign(this.h, other.cPointer()) +} + +func (this *QWebSocketHandshakeOptions) Swap(other *QWebSocketHandshakeOptions) { + C.QWebSocketHandshakeOptions_swap(this.h, other.cPointer()) +} + +func (this *QWebSocketHandshakeOptions) Subprotocols() []string { + var _ma C.struct_miqt_array = C.QWebSocketHandshakeOptions_subprotocols(this.h) + _ret := make([]string, int(_ma.len)) + _outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + var _lv_ms C.struct_miqt_string = _outCast[i] + _lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len))) + C.free(unsafe.Pointer(_lv_ms.data)) + _ret[i] = _lv_ret + } + return _ret +} + +func (this *QWebSocketHandshakeOptions) SetSubprotocols(protocols []string) { + protocols_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(protocols)))) + defer C.free(unsafe.Pointer(protocols_CArray)) + for i := range protocols { + protocols_i_ms := C.struct_miqt_string{} + protocols_i_ms.data = C.CString(protocols[i]) + protocols_i_ms.len = C.size_t(len(protocols[i])) + defer C.free(unsafe.Pointer(protocols_i_ms.data)) + protocols_CArray[i] = protocols_i_ms + } + protocols_ma := C.struct_miqt_array{len: C.size_t(len(protocols)), data: unsafe.Pointer(protocols_CArray)} + C.QWebSocketHandshakeOptions_setSubprotocols(this.h, protocols_ma) +} + +// Delete this object from C++ memory. +func (this *QWebSocketHandshakeOptions) Delete() { + C.QWebSocketHandshakeOptions_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 *QWebSocketHandshakeOptions) GoGC() { + runtime.SetFinalizer(this, func(this *QWebSocketHandshakeOptions) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/websockets/gen_qwebsockethandshakeoptions.h b/qt6/websockets/gen_qwebsockethandshakeoptions.h new file mode 100644 index 000000000..be469263e --- /dev/null +++ b/qt6/websockets/gen_qwebsockethandshakeoptions.h @@ -0,0 +1,36 @@ +#pragma once +#ifndef MIQT_QT6_WEBSOCKETS_GEN_QWEBSOCKETHANDSHAKEOPTIONS_H +#define MIQT_QT6_WEBSOCKETS_GEN_QWEBSOCKETHANDSHAKEOPTIONS_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QWebSocketHandshakeOptions; +#else +typedef struct QWebSocketHandshakeOptions QWebSocketHandshakeOptions; +#endif + +QWebSocketHandshakeOptions* QWebSocketHandshakeOptions_new(); +QWebSocketHandshakeOptions* QWebSocketHandshakeOptions_new2(QWebSocketHandshakeOptions* other); +void QWebSocketHandshakeOptions_operatorAssign(QWebSocketHandshakeOptions* self, QWebSocketHandshakeOptions* other); +void QWebSocketHandshakeOptions_swap(QWebSocketHandshakeOptions* self, QWebSocketHandshakeOptions* other); +struct miqt_array /* of struct miqt_string */ QWebSocketHandshakeOptions_subprotocols(const QWebSocketHandshakeOptions* self); +void QWebSocketHandshakeOptions_setSubprotocols(QWebSocketHandshakeOptions* self, struct miqt_array /* of struct miqt_string */ protocols); + +void QWebSocketHandshakeOptions_delete(QWebSocketHandshakeOptions* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/websockets/gen_qwebsocketprotocol.cpp b/qt6/websockets/gen_qwebsocketprotocol.cpp new file mode 100644 index 000000000..d3701f82f --- /dev/null +++ b/qt6/websockets/gen_qwebsocketprotocol.cpp @@ -0,0 +1,11 @@ +#include +#include "gen_qwebsocketprotocol.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + diff --git a/qt6/websockets/gen_qwebsocketprotocol.go b/qt6/websockets/gen_qwebsocketprotocol.go new file mode 100644 index 000000000..d48015183 --- /dev/null +++ b/qt6/websockets/gen_qwebsocketprotocol.go @@ -0,0 +1,41 @@ +package websockets + +/* + +#include "gen_qwebsocketprotocol.h" +#include + +*/ +import "C" + +type QWebSocketProtocol__Version int + +const ( + QWebSocketProtocol__VersionUnknown QWebSocketProtocol__Version = -1 + QWebSocketProtocol__Version0 QWebSocketProtocol__Version = 0 + QWebSocketProtocol__Version4 QWebSocketProtocol__Version = 4 + QWebSocketProtocol__Version5 QWebSocketProtocol__Version = 5 + QWebSocketProtocol__Version6 QWebSocketProtocol__Version = 6 + QWebSocketProtocol__Version7 QWebSocketProtocol__Version = 7 + QWebSocketProtocol__Version8 QWebSocketProtocol__Version = 8 + QWebSocketProtocol__Version13 QWebSocketProtocol__Version = 13 + QWebSocketProtocol__VersionLatest QWebSocketProtocol__Version = 13 +) + +type QWebSocketProtocol__CloseCode int + +const ( + QWebSocketProtocol__CloseCodeNormal QWebSocketProtocol__CloseCode = 1000 + QWebSocketProtocol__CloseCodeGoingAway QWebSocketProtocol__CloseCode = 1001 + QWebSocketProtocol__CloseCodeProtocolError QWebSocketProtocol__CloseCode = 1002 + QWebSocketProtocol__CloseCodeDatatypeNotSupported QWebSocketProtocol__CloseCode = 1003 + QWebSocketProtocol__CloseCodeReserved1004 QWebSocketProtocol__CloseCode = 1004 + QWebSocketProtocol__CloseCodeMissingStatusCode QWebSocketProtocol__CloseCode = 1005 + QWebSocketProtocol__CloseCodeAbnormalDisconnection QWebSocketProtocol__CloseCode = 1006 + QWebSocketProtocol__CloseCodeWrongDatatype QWebSocketProtocol__CloseCode = 1007 + QWebSocketProtocol__CloseCodePolicyViolated QWebSocketProtocol__CloseCode = 1008 + QWebSocketProtocol__CloseCodeTooMuchData QWebSocketProtocol__CloseCode = 1009 + QWebSocketProtocol__CloseCodeMissingExtension QWebSocketProtocol__CloseCode = 1010 + QWebSocketProtocol__CloseCodeBadOperation QWebSocketProtocol__CloseCode = 1011 + QWebSocketProtocol__CloseCodeTlsHandshakeFailed QWebSocketProtocol__CloseCode = 1015 +) diff --git a/qt6/websockets/gen_qwebsocketprotocol.h b/qt6/websockets/gen_qwebsocketprotocol.h new file mode 100644 index 000000000..acf338511 --- /dev/null +++ b/qt6/websockets/gen_qwebsocketprotocol.h @@ -0,0 +1,25 @@ +#pragma once +#ifndef MIQT_QT6_WEBSOCKETS_GEN_QWEBSOCKETPROTOCOL_H +#define MIQT_QT6_WEBSOCKETS_GEN_QWEBSOCKETPROTOCOL_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +#else +#endif + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif diff --git a/qt6/websockets/gen_qwebsocketserver.cpp b/qt6/websockets/gen_qwebsocketserver.cpp new file mode 100644 index 000000000..87c8dfee3 --- /dev/null +++ b/qt6/websockets/gen_qwebsocketserver.cpp @@ -0,0 +1,766 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gen_qwebsocketserver.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void miqt_exec_callback_QWebSocketServer_acceptError(intptr_t, int); +void miqt_exec_callback_QWebSocketServer_serverError(intptr_t, int); +void miqt_exec_callback_QWebSocketServer_originAuthenticationRequired(intptr_t, QWebSocketCorsAuthenticator*); +void miqt_exec_callback_QWebSocketServer_newConnection(intptr_t); +void miqt_exec_callback_QWebSocketServer_peerVerifyError(intptr_t, QSslError*); +void miqt_exec_callback_QWebSocketServer_sslErrors(intptr_t, struct miqt_array /* of QSslError* */ ); +void miqt_exec_callback_QWebSocketServer_preSharedKeyAuthenticationRequired(intptr_t, QSslPreSharedKeyAuthenticator*); +void miqt_exec_callback_QWebSocketServer_alertSent(intptr_t, int, int, struct miqt_string); +void miqt_exec_callback_QWebSocketServer_alertReceived(intptr_t, int, int, struct miqt_string); +void miqt_exec_callback_QWebSocketServer_handshakeInterruptedOnError(intptr_t, QSslError*); +void miqt_exec_callback_QWebSocketServer_closed(intptr_t); +QWebSocket* miqt_exec_callback_QWebSocketServer_nextPendingConnection(QWebSocketServer*, intptr_t); +bool miqt_exec_callback_QWebSocketServer_event(QWebSocketServer*, intptr_t, QEvent*); +bool miqt_exec_callback_QWebSocketServer_eventFilter(QWebSocketServer*, intptr_t, QObject*, QEvent*); +void miqt_exec_callback_QWebSocketServer_timerEvent(QWebSocketServer*, intptr_t, QTimerEvent*); +void miqt_exec_callback_QWebSocketServer_childEvent(QWebSocketServer*, intptr_t, QChildEvent*); +void miqt_exec_callback_QWebSocketServer_customEvent(QWebSocketServer*, intptr_t, QEvent*); +void miqt_exec_callback_QWebSocketServer_connectNotify(QWebSocketServer*, intptr_t, QMetaMethod*); +void miqt_exec_callback_QWebSocketServer_disconnectNotify(QWebSocketServer*, intptr_t, QMetaMethod*); +#ifdef __cplusplus +} /* extern C */ +#endif + +class MiqtVirtualQWebSocketServer final : public QWebSocketServer { +public: + + MiqtVirtualQWebSocketServer(const QString& serverName, QWebSocketServer::SslMode secureMode): QWebSocketServer(serverName, secureMode) {} + MiqtVirtualQWebSocketServer(const QString& serverName, QWebSocketServer::SslMode secureMode, QObject* parent): QWebSocketServer(serverName, secureMode, parent) {} + + virtual ~MiqtVirtualQWebSocketServer() override = default; + + // cgo.Handle value for overwritten implementation + intptr_t handle__nextPendingConnection = 0; + + // Subclass to allow providing a Go implementation + virtual QWebSocket* nextPendingConnection() override { + if (handle__nextPendingConnection == 0) { + return QWebSocketServer::nextPendingConnection(); + } + + QWebSocket* callback_return_value = miqt_exec_callback_QWebSocketServer_nextPendingConnection(this, handle__nextPendingConnection); + return callback_return_value; + } + + friend QWebSocket* QWebSocketServer_virtualbase_nextPendingConnection(void* self); + + // cgo.Handle value for overwritten implementation + intptr_t handle__event = 0; + + // Subclass to allow providing a Go implementation + virtual bool event(QEvent* event) override { + if (handle__event == 0) { + return QWebSocketServer::event(event); + } + + QEvent* sigval1 = event; + bool callback_return_value = miqt_exec_callback_QWebSocketServer_event(this, handle__event, sigval1); + return callback_return_value; + } + + friend bool QWebSocketServer_virtualbase_event(void* self, QEvent* event); + + // cgo.Handle value for overwritten implementation + intptr_t handle__eventFilter = 0; + + // Subclass to allow providing a Go implementation + virtual bool eventFilter(QObject* watched, QEvent* event) override { + if (handle__eventFilter == 0) { + return QWebSocketServer::eventFilter(watched, event); + } + + QObject* sigval1 = watched; + QEvent* sigval2 = event; + bool callback_return_value = miqt_exec_callback_QWebSocketServer_eventFilter(this, handle__eventFilter, sigval1, sigval2); + return callback_return_value; + } + + friend bool QWebSocketServer_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) { + QWebSocketServer::timerEvent(event); + return; + } + + QTimerEvent* sigval1 = event; + miqt_exec_callback_QWebSocketServer_timerEvent(this, handle__timerEvent, sigval1); + + } + + friend void QWebSocketServer_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) { + QWebSocketServer::childEvent(event); + return; + } + + QChildEvent* sigval1 = event; + miqt_exec_callback_QWebSocketServer_childEvent(this, handle__childEvent, sigval1); + + } + + friend void QWebSocketServer_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) { + QWebSocketServer::customEvent(event); + return; + } + + QEvent* sigval1 = event; + miqt_exec_callback_QWebSocketServer_customEvent(this, handle__customEvent, sigval1); + + } + + friend void QWebSocketServer_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) { + QWebSocketServer::connectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QWebSocketServer_connectNotify(this, handle__connectNotify, sigval1); + + } + + friend void QWebSocketServer_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) { + QWebSocketServer::disconnectNotify(signal); + return; + } + + const QMetaMethod& signal_ret = signal; + // Cast returned reference into pointer + QMetaMethod* sigval1 = const_cast(&signal_ret); + miqt_exec_callback_QWebSocketServer_disconnectNotify(this, handle__disconnectNotify, sigval1); + + } + + friend void QWebSocketServer_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + + // Wrappers to allow calling protected methods: + friend QObject* QWebSocketServer_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); + friend int QWebSocketServer_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); + friend int QWebSocketServer_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); + friend bool QWebSocketServer_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); +}; + +QWebSocketServer* QWebSocketServer_new(struct miqt_string serverName, int secureMode) { + QString serverName_QString = QString::fromUtf8(serverName.data, serverName.len); + return new (std::nothrow) MiqtVirtualQWebSocketServer(serverName_QString, static_cast(secureMode)); +} + +QWebSocketServer* QWebSocketServer_new2(struct miqt_string serverName, int secureMode, QObject* parent) { + QString serverName_QString = QString::fromUtf8(serverName.data, serverName.len); + return new (std::nothrow) MiqtVirtualQWebSocketServer(serverName_QString, static_cast(secureMode), parent); +} + +void QWebSocketServer_virtbase(QWebSocketServer* src, QObject** outptr_QObject) { + *outptr_QObject = static_cast(src); +} + +QMetaObject* QWebSocketServer_metaObject(const QWebSocketServer* self) { + return (QMetaObject*) self->metaObject(); +} + +void* QWebSocketServer_metacast(QWebSocketServer* self, const char* param1) { + return self->qt_metacast(param1); +} + +struct miqt_string QWebSocketServer_tr(const char* s) { + QString _ret = QWebSocketServer::tr(s); + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _b = _ret.toUtf8(); + struct miqt_string _ms; + _ms.len = _b.length(); + _ms.data = static_cast(malloc(_ms.len)); + memcpy(_ms.data, _b.data(), _ms.len); + return _ms; +} + +bool QWebSocketServer_listen(QWebSocketServer* self) { + return self->listen(); +} + +void QWebSocketServer_close(QWebSocketServer* self) { + self->close(); +} + +bool QWebSocketServer_isListening(const QWebSocketServer* self) { + return self->isListening(); +} + +void QWebSocketServer_setMaxPendingConnections(QWebSocketServer* self, int numConnections) { + self->setMaxPendingConnections(static_cast(numConnections)); +} + +int QWebSocketServer_maxPendingConnections(const QWebSocketServer* self) { + return self->maxPendingConnections(); +} + +void QWebSocketServer_setHandshakeTimeoutWithMsec(QWebSocketServer* self, int msec) { + self->setHandshakeTimeout(static_cast(msec)); +} + +int QWebSocketServer_handshakeTimeoutMS(const QWebSocketServer* self) { + return self->handshakeTimeoutMS(); +} + +unsigned short QWebSocketServer_serverPort(const QWebSocketServer* self) { + quint16 _ret = self->serverPort(); + return static_cast(_ret); +} + +QHostAddress* QWebSocketServer_serverAddress(const QWebSocketServer* self) { + return new QHostAddress(self->serverAddress()); +} + +QUrl* QWebSocketServer_serverUrl(const QWebSocketServer* self) { + return new QUrl(self->serverUrl()); +} + +int QWebSocketServer_secureMode(const QWebSocketServer* self) { + QWebSocketServer::SslMode _ret = self->secureMode(); + return static_cast(_ret); +} + +bool QWebSocketServer_setSocketDescriptor(QWebSocketServer* self, intptr_t socketDescriptor) { + return self->setSocketDescriptor((qintptr)(socketDescriptor)); +} + +intptr_t QWebSocketServer_socketDescriptor(const QWebSocketServer* self) { + qintptr _ret = self->socketDescriptor(); + return (intptr_t)(_ret); +} + +bool QWebSocketServer_setNativeDescriptor(QWebSocketServer* self, intptr_t descriptor) { + return self->setNativeDescriptor((qintptr)(descriptor)); +} + +intptr_t QWebSocketServer_nativeDescriptor(const QWebSocketServer* self) { + qintptr _ret = self->nativeDescriptor(); + return (intptr_t)(_ret); +} + +bool QWebSocketServer_hasPendingConnections(const QWebSocketServer* self) { + return self->hasPendingConnections(); +} + +QWebSocket* QWebSocketServer_nextPendingConnection(QWebSocketServer* self) { + return self->nextPendingConnection(); +} + +int QWebSocketServer_error(const QWebSocketServer* self) { + QWebSocketProtocol::CloseCode _ret = self->error(); + return static_cast(_ret); +} + +struct miqt_string QWebSocketServer_errorString(const QWebSocketServer* 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 QWebSocketServer_pauseAccepting(QWebSocketServer* self) { + self->pauseAccepting(); +} + +void QWebSocketServer_resumeAccepting(QWebSocketServer* self) { + self->resumeAccepting(); +} + +void QWebSocketServer_setServerName(QWebSocketServer* self, struct miqt_string serverName) { + QString serverName_QString = QString::fromUtf8(serverName.data, serverName.len); + self->setServerName(serverName_QString); +} + +struct miqt_string QWebSocketServer_serverName(const QWebSocketServer* self) { + QString _ret = self->serverName(); + // 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 QWebSocketServer_setSupportedSubprotocols(QWebSocketServer* self, struct miqt_array /* of struct miqt_string */ protocols) { + QStringList protocols_QList; + protocols_QList.reserve(protocols.len); + struct miqt_string* protocols_arr = static_cast(protocols.data); + for(size_t i = 0; i < protocols.len; ++i) { + QString protocols_arr_i_QString = QString::fromUtf8(protocols_arr[i].data, protocols_arr[i].len); + protocols_QList.push_back(protocols_arr_i_QString); + } + self->setSupportedSubprotocols(protocols_QList); +} + +struct miqt_array /* of struct miqt_string */ QWebSocketServer_supportedSubprotocols(const QWebSocketServer* self) { + QStringList _ret = self->supportedSubprotocols(); + // Convert QList<> from C++ memory to manually-managed C memory + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QString _lv_ret = _ret[i]; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray _lv_b = _lv_ret.toUtf8(); + struct miqt_string _lv_ms; + _lv_ms.len = _lv_b.length(); + _lv_ms.data = static_cast(malloc(_lv_ms.len)); + memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len); + _arr[i] = _lv_ms; + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +void QWebSocketServer_setProxy(QWebSocketServer* self, QNetworkProxy* networkProxy) { + self->setProxy(*networkProxy); +} + +QNetworkProxy* QWebSocketServer_proxy(const QWebSocketServer* self) { + return new QNetworkProxy(self->proxy()); +} + +void QWebSocketServer_setSslConfiguration(QWebSocketServer* self, QSslConfiguration* sslConfiguration) { + self->setSslConfiguration(*sslConfiguration); +} + +QSslConfiguration* QWebSocketServer_sslConfiguration(const QWebSocketServer* self) { + return new QSslConfiguration(self->sslConfiguration()); +} + +struct miqt_array /* of int */ QWebSocketServer_supportedVersions(const QWebSocketServer* self) { + QList _ret = self->supportedVersions(); + // Convert QList<> from C++ memory to manually-managed C memory + int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebSocketProtocol::Version _lv_ret = _ret[i]; + _arr[i] = static_cast(_lv_ret); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + +void QWebSocketServer_handleConnection(const QWebSocketServer* self, QTcpSocket* socket) { + self->handleConnection(socket); +} + +void QWebSocketServer_acceptError(QWebSocketServer* self, int socketError) { + self->acceptError(static_cast(socketError)); +} + +void QWebSocketServer_connect_acceptError(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::acceptError), self, [=](QAbstractSocket::SocketError socketError) { + QAbstractSocket::SocketError socketError_ret = socketError; + int sigval1 = static_cast(socketError_ret); + miqt_exec_callback_QWebSocketServer_acceptError(slot, sigval1); + }); +} + +void QWebSocketServer_serverError(QWebSocketServer* self, int closeCode) { + self->serverError(static_cast(closeCode)); +} + +void QWebSocketServer_connect_serverError(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::serverError), self, [=](QWebSocketProtocol::CloseCode closeCode) { + QWebSocketProtocol::CloseCode closeCode_ret = closeCode; + int sigval1 = static_cast(closeCode_ret); + miqt_exec_callback_QWebSocketServer_serverError(slot, sigval1); + }); +} + +void QWebSocketServer_originAuthenticationRequired(QWebSocketServer* self, QWebSocketCorsAuthenticator* pAuthenticator) { + self->originAuthenticationRequired(pAuthenticator); +} + +void QWebSocketServer_connect_originAuthenticationRequired(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::originAuthenticationRequired), self, [=](QWebSocketCorsAuthenticator* pAuthenticator) { + QWebSocketCorsAuthenticator* sigval1 = pAuthenticator; + miqt_exec_callback_QWebSocketServer_originAuthenticationRequired(slot, sigval1); + }); +} + +void QWebSocketServer_newConnection(QWebSocketServer* self) { + self->newConnection(); +} + +void QWebSocketServer_connect_newConnection(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::newConnection), self, [=]() { + miqt_exec_callback_QWebSocketServer_newConnection(slot); + }); +} + +void QWebSocketServer_peerVerifyError(QWebSocketServer* self, QSslError* error) { + self->peerVerifyError(*error); +} + +void QWebSocketServer_connect_peerVerifyError(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::peerVerifyError), self, [=](const QSslError& error) { + const QSslError& error_ret = error; + // Cast returned reference into pointer + QSslError* sigval1 = const_cast(&error_ret); + miqt_exec_callback_QWebSocketServer_peerVerifyError(slot, sigval1); + }); +} + +void QWebSocketServer_sslErrors(QWebSocketServer* self, struct miqt_array /* of QSslError* */ errors) { + QList errors_QList; + errors_QList.reserve(errors.len); + QSslError** errors_arr = static_cast(errors.data); + for(size_t i = 0; i < errors.len; ++i) { + errors_QList.push_back(*(errors_arr[i])); + } + self->sslErrors(errors_QList); +} + +void QWebSocketServer_connect_sslErrors(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast&)>(&QWebSocketServer::sslErrors), self, [=](const QList& errors) { + const QList& errors_ret = errors; + // Convert QList<> from C++ memory to manually-managed C memory + QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.length())); + for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { + errors_arr[i] = new QSslError(errors_ret[i]); + } + struct miqt_array errors_out; + errors_out.len = errors_ret.length(); + errors_out.data = static_cast(errors_arr); + struct miqt_array /* of QSslError* */ sigval1 = errors_out; + miqt_exec_callback_QWebSocketServer_sslErrors(slot, sigval1); + }); +} + +void QWebSocketServer_preSharedKeyAuthenticationRequired(QWebSocketServer* self, QSslPreSharedKeyAuthenticator* authenticator) { + self->preSharedKeyAuthenticationRequired(authenticator); +} + +void QWebSocketServer_connect_preSharedKeyAuthenticationRequired(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::preSharedKeyAuthenticationRequired), self, [=](QSslPreSharedKeyAuthenticator* authenticator) { + QSslPreSharedKeyAuthenticator* sigval1 = authenticator; + miqt_exec_callback_QWebSocketServer_preSharedKeyAuthenticationRequired(slot, sigval1); + }); +} + +void QWebSocketServer_alertSent(QWebSocketServer* self, int level, int type, struct miqt_string description) { + QString description_QString = QString::fromUtf8(description.data, description.len); + self->alertSent(static_cast(level), static_cast(type), description_QString); +} + +void QWebSocketServer_connect_alertSent(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::alertSent), self, [=](QSsl::AlertLevel level, QSsl::AlertType type, const QString& description) { + QSsl::AlertLevel level_ret = level; + int sigval1 = static_cast(level_ret); + QSsl::AlertType type_ret = type; + int sigval2 = static_cast(type_ret); + const QString description_ret = description; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray description_b = description_ret.toUtf8(); + struct miqt_string description_ms; + description_ms.len = description_b.length(); + description_ms.data = static_cast(malloc(description_ms.len)); + memcpy(description_ms.data, description_b.data(), description_ms.len); + struct miqt_string sigval3 = description_ms; + miqt_exec_callback_QWebSocketServer_alertSent(slot, sigval1, sigval2, sigval3); + }); +} + +void QWebSocketServer_alertReceived(QWebSocketServer* self, int level, int type, struct miqt_string description) { + QString description_QString = QString::fromUtf8(description.data, description.len); + self->alertReceived(static_cast(level), static_cast(type), description_QString); +} + +void QWebSocketServer_connect_alertReceived(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::alertReceived), self, [=](QSsl::AlertLevel level, QSsl::AlertType type, const QString& description) { + QSsl::AlertLevel level_ret = level; + int sigval1 = static_cast(level_ret); + QSsl::AlertType type_ret = type; + int sigval2 = static_cast(type_ret); + const QString description_ret = description; + // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory + QByteArray description_b = description_ret.toUtf8(); + struct miqt_string description_ms; + description_ms.len = description_b.length(); + description_ms.data = static_cast(malloc(description_ms.len)); + memcpy(description_ms.data, description_b.data(), description_ms.len); + struct miqt_string sigval3 = description_ms; + miqt_exec_callback_QWebSocketServer_alertReceived(slot, sigval1, sigval2, sigval3); + }); +} + +void QWebSocketServer_handshakeInterruptedOnError(QWebSocketServer* self, QSslError* error) { + self->handshakeInterruptedOnError(*error); +} + +void QWebSocketServer_connect_handshakeInterruptedOnError(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::handshakeInterruptedOnError), self, [=](const QSslError& error) { + const QSslError& error_ret = error; + // Cast returned reference into pointer + QSslError* sigval1 = const_cast(&error_ret); + miqt_exec_callback_QWebSocketServer_handshakeInterruptedOnError(slot, sigval1); + }); +} + +void QWebSocketServer_closed(QWebSocketServer* self) { + self->closed(); +} + +void QWebSocketServer_connect_closed(QWebSocketServer* self, intptr_t slot) { + QWebSocketServer::connect(self, static_cast(&QWebSocketServer::closed), self, [=]() { + miqt_exec_callback_QWebSocketServer_closed(slot); + }); +} + +struct miqt_string QWebSocketServer_tr2(const char* s, const char* c) { + QString _ret = QWebSocketServer::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 QWebSocketServer_tr3(const char* s, const char* c, int n) { + QString _ret = QWebSocketServer::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 QWebSocketServer_listenWithAddress(QWebSocketServer* self, QHostAddress* address) { + return self->listen(*address); +} + +bool QWebSocketServer_listen2(QWebSocketServer* self, QHostAddress* address, unsigned short port) { + return self->listen(*address, static_cast(port)); +} + +bool QWebSocketServer_override_virtual_nextPendingConnection(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__nextPendingConnection = slot; + return true; +} + +QWebSocket* QWebSocketServer_virtualbase_nextPendingConnection(void* self) { + return static_cast(self)->QWebSocketServer::nextPendingConnection(); +} + +bool QWebSocketServer_override_virtual_event(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__event = slot; + return true; +} + +bool QWebSocketServer_virtualbase_event(void* self, QEvent* event) { + return static_cast(self)->QWebSocketServer::event(event); +} + +bool QWebSocketServer_override_virtual_eventFilter(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__eventFilter = slot; + return true; +} + +bool QWebSocketServer_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { + return static_cast(self)->QWebSocketServer::eventFilter(watched, event); +} + +bool QWebSocketServer_override_virtual_timerEvent(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__timerEvent = slot; + return true; +} + +void QWebSocketServer_virtualbase_timerEvent(void* self, QTimerEvent* event) { + static_cast(self)->QWebSocketServer::timerEvent(event); +} + +bool QWebSocketServer_override_virtual_childEvent(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__childEvent = slot; + return true; +} + +void QWebSocketServer_virtualbase_childEvent(void* self, QChildEvent* event) { + static_cast(self)->QWebSocketServer::childEvent(event); +} + +bool QWebSocketServer_override_virtual_customEvent(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__customEvent = slot; + return true; +} + +void QWebSocketServer_virtualbase_customEvent(void* self, QEvent* event) { + static_cast(self)->QWebSocketServer::customEvent(event); +} + +bool QWebSocketServer_override_virtual_connectNotify(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__connectNotify = slot; + return true; +} + +void QWebSocketServer_virtualbase_connectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QWebSocketServer::connectNotify(*signal); +} + +bool QWebSocketServer_override_virtual_disconnectNotify(void* self, intptr_t slot) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + return false; + } + + self_cast->handle__disconnectNotify = slot; + return true; +} + +void QWebSocketServer_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { + static_cast(self)->QWebSocketServer::disconnectNotify(*signal); +} + +QObject* QWebSocketServer_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return nullptr; + } + + *_dynamic_cast_ok = true; + return self_cast->sender(); +} + +int QWebSocketServer_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->senderSignalIndex(); +} + +int QWebSocketServer_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return 0; + } + + *_dynamic_cast_ok = true; + return self_cast->receivers(signal); +} + +bool QWebSocketServer_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { + MiqtVirtualQWebSocketServer* self_cast = dynamic_cast( (QWebSocketServer*)(self) ); + if (self_cast == nullptr) { + *_dynamic_cast_ok = false; + return false; + } + + *_dynamic_cast_ok = true; + return self_cast->isSignalConnected(*signal); +} + +void QWebSocketServer_delete(QWebSocketServer* self) { + delete self; +} + diff --git a/qt6/websockets/gen_qwebsocketserver.go b/qt6/websockets/gen_qwebsocketserver.go new file mode 100644 index 000000000..fd31dafe8 --- /dev/null +++ b/qt6/websockets/gen_qwebsocketserver.go @@ -0,0 +1,831 @@ +package websockets + +/* + +#include "gen_qwebsocketserver.h" +#include + +*/ +import "C" + +import ( + "github.com/mappu/miqt/qt6" + "github.com/mappu/miqt/qt6/network" + "runtime" + "runtime/cgo" + "unsafe" +) + +type QWebSocketServer__SslMode int + +const ( + QWebSocketServer__SecureMode QWebSocketServer__SslMode = 0 + QWebSocketServer__NonSecureMode QWebSocketServer__SslMode = 1 +) + +type QWebSocketServer struct { + h *C.QWebSocketServer + *qt6.QObject +} + +func (this *QWebSocketServer) cPointer() *C.QWebSocketServer { + if this == nil { + return nil + } + return this.h +} + +func (this *QWebSocketServer) UnsafePointer() unsafe.Pointer { + if this == nil { + return nil + } + return unsafe.Pointer(this.h) +} + +// newQWebSocketServer constructs the type using only CGO pointers. +func newQWebSocketServer(h *C.QWebSocketServer) *QWebSocketServer { + if h == nil { + return nil + } + var outptr_QObject *C.QObject = nil + C.QWebSocketServer_virtbase(h, &outptr_QObject) + + return &QWebSocketServer{h: h, + QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))} +} + +// UnsafeNewQWebSocketServer constructs the type using only unsafe pointers. +func UnsafeNewQWebSocketServer(h unsafe.Pointer) *QWebSocketServer { + return newQWebSocketServer((*C.QWebSocketServer)(h)) +} + +// NewQWebSocketServer constructs a new QWebSocketServer object. +func NewQWebSocketServer(serverName string, secureMode QWebSocketServer__SslMode) *QWebSocketServer { + serverName_ms := C.struct_miqt_string{} + serverName_ms.data = C.CString(serverName) + serverName_ms.len = C.size_t(len(serverName)) + defer C.free(unsafe.Pointer(serverName_ms.data)) + + return newQWebSocketServer(C.QWebSocketServer_new(serverName_ms, (C.int)(secureMode))) +} + +// NewQWebSocketServer2 constructs a new QWebSocketServer object. +func NewQWebSocketServer2(serverName string, secureMode QWebSocketServer__SslMode, parent *qt6.QObject) *QWebSocketServer { + serverName_ms := C.struct_miqt_string{} + serverName_ms.data = C.CString(serverName) + serverName_ms.len = C.size_t(len(serverName)) + defer C.free(unsafe.Pointer(serverName_ms.data)) + + return newQWebSocketServer(C.QWebSocketServer_new2(serverName_ms, (C.int)(secureMode), (*C.QObject)(parent.UnsafePointer()))) +} + +func (this *QWebSocketServer) MetaObject() *qt6.QMetaObject { + return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QWebSocketServer_metaObject(this.h))) +} + +func (this *QWebSocketServer) Metacast(param1 string) unsafe.Pointer { + param1_Cstring := C.CString(param1) + defer C.free(unsafe.Pointer(param1_Cstring)) + return (unsafe.Pointer)(C.QWebSocketServer_metacast(this.h, param1_Cstring)) +} + +func QWebSocketServer_Tr(s string) string { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + var _ms C.struct_miqt_string = C.QWebSocketServer_tr(s_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocketServer) Listen() bool { + return (bool)(C.QWebSocketServer_listen(this.h)) +} + +func (this *QWebSocketServer) Close() { + C.QWebSocketServer_close(this.h) +} + +func (this *QWebSocketServer) IsListening() bool { + return (bool)(C.QWebSocketServer_isListening(this.h)) +} + +func (this *QWebSocketServer) SetMaxPendingConnections(numConnections int) { + C.QWebSocketServer_setMaxPendingConnections(this.h, (C.int)(numConnections)) +} + +func (this *QWebSocketServer) MaxPendingConnections() int { + return (int)(C.QWebSocketServer_maxPendingConnections(this.h)) +} + +func (this *QWebSocketServer) SetHandshakeTimeoutWithMsec(msec int) { + C.QWebSocketServer_setHandshakeTimeoutWithMsec(this.h, (C.int)(msec)) +} + +func (this *QWebSocketServer) HandshakeTimeoutMS() int { + return (int)(C.QWebSocketServer_handshakeTimeoutMS(this.h)) +} + +func (this *QWebSocketServer) ServerPort() uint16 { + return (uint16)(C.QWebSocketServer_serverPort(this.h)) +} + +func (this *QWebSocketServer) ServerAddress() *network.QHostAddress { + _goptr := network.UnsafeNewQHostAddress(unsafe.Pointer(C.QWebSocketServer_serverAddress(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocketServer) ServerUrl() *qt6.QUrl { + _goptr := qt6.UnsafeNewQUrl(unsafe.Pointer(C.QWebSocketServer_serverUrl(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocketServer) SecureMode() QWebSocketServer__SslMode { + return (QWebSocketServer__SslMode)(C.QWebSocketServer_secureMode(this.h)) +} + +func (this *QWebSocketServer) SetSocketDescriptor(socketDescriptor uintptr) bool { + return (bool)(C.QWebSocketServer_setSocketDescriptor(this.h, (C.intptr_t)(socketDescriptor))) +} + +func (this *QWebSocketServer) SocketDescriptor() uintptr { + return (uintptr)(C.QWebSocketServer_socketDescriptor(this.h)) +} + +func (this *QWebSocketServer) SetNativeDescriptor(descriptor uintptr) bool { + return (bool)(C.QWebSocketServer_setNativeDescriptor(this.h, (C.intptr_t)(descriptor))) +} + +func (this *QWebSocketServer) NativeDescriptor() uintptr { + return (uintptr)(C.QWebSocketServer_nativeDescriptor(this.h)) +} + +func (this *QWebSocketServer) HasPendingConnections() bool { + return (bool)(C.QWebSocketServer_hasPendingConnections(this.h)) +} + +func (this *QWebSocketServer) NextPendingConnection() *QWebSocket { + return newQWebSocket(C.QWebSocketServer_nextPendingConnection(this.h)) +} + +func (this *QWebSocketServer) Error() QWebSocketProtocol__CloseCode { + return (QWebSocketProtocol__CloseCode)(C.QWebSocketServer_error(this.h)) +} + +func (this *QWebSocketServer) ErrorString() string { + var _ms C.struct_miqt_string = C.QWebSocketServer_errorString(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocketServer) PauseAccepting() { + C.QWebSocketServer_pauseAccepting(this.h) +} + +func (this *QWebSocketServer) ResumeAccepting() { + C.QWebSocketServer_resumeAccepting(this.h) +} + +func (this *QWebSocketServer) SetServerName(serverName string) { + serverName_ms := C.struct_miqt_string{} + serverName_ms.data = C.CString(serverName) + serverName_ms.len = C.size_t(len(serverName)) + defer C.free(unsafe.Pointer(serverName_ms.data)) + C.QWebSocketServer_setServerName(this.h, serverName_ms) +} + +func (this *QWebSocketServer) ServerName() string { + var _ms C.struct_miqt_string = C.QWebSocketServer_serverName(this.h) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func (this *QWebSocketServer) SetSupportedSubprotocols(protocols []string) { + protocols_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(protocols)))) + defer C.free(unsafe.Pointer(protocols_CArray)) + for i := range protocols { + protocols_i_ms := C.struct_miqt_string{} + protocols_i_ms.data = C.CString(protocols[i]) + protocols_i_ms.len = C.size_t(len(protocols[i])) + defer C.free(unsafe.Pointer(protocols_i_ms.data)) + protocols_CArray[i] = protocols_i_ms + } + protocols_ma := C.struct_miqt_array{len: C.size_t(len(protocols)), data: unsafe.Pointer(protocols_CArray)} + C.QWebSocketServer_setSupportedSubprotocols(this.h, protocols_ma) +} + +func (this *QWebSocketServer) SupportedSubprotocols() []string { + var _ma C.struct_miqt_array = C.QWebSocketServer_supportedSubprotocols(this.h) + _ret := make([]string, int(_ma.len)) + _outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + var _lv_ms C.struct_miqt_string = _outCast[i] + _lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len))) + C.free(unsafe.Pointer(_lv_ms.data)) + _ret[i] = _lv_ret + } + return _ret +} + +func (this *QWebSocketServer) SetProxy(networkProxy *network.QNetworkProxy) { + C.QWebSocketServer_setProxy(this.h, (*C.QNetworkProxy)(networkProxy.UnsafePointer())) +} + +func (this *QWebSocketServer) Proxy() *network.QNetworkProxy { + _goptr := network.UnsafeNewQNetworkProxy(unsafe.Pointer(C.QWebSocketServer_proxy(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocketServer) SetSslConfiguration(sslConfiguration *network.QSslConfiguration) { + C.QWebSocketServer_setSslConfiguration(this.h, (*C.QSslConfiguration)(sslConfiguration.UnsafePointer())) +} + +func (this *QWebSocketServer) SslConfiguration() *network.QSslConfiguration { + _goptr := network.UnsafeNewQSslConfiguration(unsafe.Pointer(C.QWebSocketServer_sslConfiguration(this.h))) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QWebSocketServer) SupportedVersions() []QWebSocketProtocol__Version { + var _ma C.struct_miqt_array = C.QWebSocketServer_supportedVersions(this.h) + _ret := make([]QWebSocketProtocol__Version, int(_ma.len)) + _outCast := (*[0xffff]C.int)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _ret[i] = (QWebSocketProtocol__Version)(_outCast[i]) + } + return _ret +} + +func (this *QWebSocketServer) HandleConnection(socket *network.QTcpSocket) { + C.QWebSocketServer_handleConnection(this.h, (*C.QTcpSocket)(socket.UnsafePointer())) +} + +func (this *QWebSocketServer) AcceptError(socketError network.QAbstractSocket__SocketError) { + C.QWebSocketServer_acceptError(this.h, (C.int)(socketError)) +} +func (this *QWebSocketServer) OnAcceptError(slot func(socketError network.QAbstractSocket__SocketError)) { + C.QWebSocketServer_connect_acceptError(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_acceptError +func miqt_exec_callback_QWebSocketServer_acceptError(cb C.intptr_t, socketError C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(socketError network.QAbstractSocket__SocketError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (network.QAbstractSocket__SocketError)(socketError) + + gofunc(slotval1) +} + +func (this *QWebSocketServer) ServerError(closeCode QWebSocketProtocol__CloseCode) { + C.QWebSocketServer_serverError(this.h, (C.int)(closeCode)) +} +func (this *QWebSocketServer) OnServerError(slot func(closeCode QWebSocketProtocol__CloseCode)) { + C.QWebSocketServer_connect_serverError(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_serverError +func miqt_exec_callback_QWebSocketServer_serverError(cb C.intptr_t, closeCode C.int) { + gofunc, ok := cgo.Handle(cb).Value().(func(closeCode QWebSocketProtocol__CloseCode)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (QWebSocketProtocol__CloseCode)(closeCode) + + gofunc(slotval1) +} + +func (this *QWebSocketServer) OriginAuthenticationRequired(pAuthenticator *QWebSocketCorsAuthenticator) { + C.QWebSocketServer_originAuthenticationRequired(this.h, pAuthenticator.cPointer()) +} +func (this *QWebSocketServer) OnOriginAuthenticationRequired(slot func(pAuthenticator *QWebSocketCorsAuthenticator)) { + C.QWebSocketServer_connect_originAuthenticationRequired(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_originAuthenticationRequired +func miqt_exec_callback_QWebSocketServer_originAuthenticationRequired(cb C.intptr_t, pAuthenticator *C.QWebSocketCorsAuthenticator) { + gofunc, ok := cgo.Handle(cb).Value().(func(pAuthenticator *QWebSocketCorsAuthenticator)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := newQWebSocketCorsAuthenticator(pAuthenticator) + + gofunc(slotval1) +} + +func (this *QWebSocketServer) NewConnection() { + C.QWebSocketServer_newConnection(this.h) +} +func (this *QWebSocketServer) OnNewConnection(slot func()) { + C.QWebSocketServer_connect_newConnection(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_newConnection +func miqt_exec_callback_QWebSocketServer_newConnection(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 *QWebSocketServer) PeerVerifyError(error *network.QSslError) { + C.QWebSocketServer_peerVerifyError(this.h, (*C.QSslError)(error.UnsafePointer())) +} +func (this *QWebSocketServer) OnPeerVerifyError(slot func(error *network.QSslError)) { + C.QWebSocketServer_connect_peerVerifyError(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_peerVerifyError +func miqt_exec_callback_QWebSocketServer_peerVerifyError(cb C.intptr_t, error *C.QSslError) { + gofunc, ok := cgo.Handle(cb).Value().(func(error *network.QSslError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := network.UnsafeNewQSslError(unsafe.Pointer(error)) + + gofunc(slotval1) +} + +func (this *QWebSocketServer) SslErrors(errors []network.QSslError) { + errors_CArray := (*[0xffff]*C.QSslError)(C.malloc(C.size_t(8 * len(errors)))) + defer C.free(unsafe.Pointer(errors_CArray)) + for i := range errors { + errors_CArray[i] = (*C.QSslError)(errors[i].UnsafePointer()) + } + errors_ma := C.struct_miqt_array{len: C.size_t(len(errors)), data: unsafe.Pointer(errors_CArray)} + C.QWebSocketServer_sslErrors(this.h, errors_ma) +} +func (this *QWebSocketServer) OnSslErrors(slot func(errors []network.QSslError)) { + C.QWebSocketServer_connect_sslErrors(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_sslErrors +func miqt_exec_callback_QWebSocketServer_sslErrors(cb C.intptr_t, errors C.struct_miqt_array) { + gofunc, ok := cgo.Handle(cb).Value().(func(errors []network.QSslError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + var errors_ma C.struct_miqt_array = errors + errors_ret := make([]network.QSslError, int(errors_ma.len)) + errors_outCast := (*[0xffff]*C.QSslError)(unsafe.Pointer(errors_ma.data)) // hey ya + for i := 0; i < int(errors_ma.len); i++ { + errors_lv_goptr := network.UnsafeNewQSslError(unsafe.Pointer(errors_outCast[i])) + errors_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + errors_ret[i] = *errors_lv_goptr + } + slotval1 := errors_ret + + gofunc(slotval1) +} + +func (this *QWebSocketServer) PreSharedKeyAuthenticationRequired(authenticator *network.QSslPreSharedKeyAuthenticator) { + C.QWebSocketServer_preSharedKeyAuthenticationRequired(this.h, (*C.QSslPreSharedKeyAuthenticator)(authenticator.UnsafePointer())) +} +func (this *QWebSocketServer) OnPreSharedKeyAuthenticationRequired(slot func(authenticator *network.QSslPreSharedKeyAuthenticator)) { + C.QWebSocketServer_connect_preSharedKeyAuthenticationRequired(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_preSharedKeyAuthenticationRequired +func miqt_exec_callback_QWebSocketServer_preSharedKeyAuthenticationRequired(cb C.intptr_t, authenticator *C.QSslPreSharedKeyAuthenticator) { + gofunc, ok := cgo.Handle(cb).Value().(func(authenticator *network.QSslPreSharedKeyAuthenticator)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := network.UnsafeNewQSslPreSharedKeyAuthenticator(unsafe.Pointer(authenticator)) + + gofunc(slotval1) +} + +func (this *QWebSocketServer) AlertSent(level network.QSsl__AlertLevel, typeVal network.QSsl__AlertType, description string) { + description_ms := C.struct_miqt_string{} + description_ms.data = C.CString(description) + description_ms.len = C.size_t(len(description)) + defer C.free(unsafe.Pointer(description_ms.data)) + C.QWebSocketServer_alertSent(this.h, (C.int)(level), (C.int)(typeVal), description_ms) +} +func (this *QWebSocketServer) OnAlertSent(slot func(level network.QSsl__AlertLevel, typeVal network.QSsl__AlertType, description string)) { + C.QWebSocketServer_connect_alertSent(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_alertSent +func miqt_exec_callback_QWebSocketServer_alertSent(cb C.intptr_t, level C.int, typeVal C.int, description C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(level network.QSsl__AlertLevel, typeVal network.QSsl__AlertType, description string)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (network.QSsl__AlertLevel)(level) + + slotval2 := (network.QSsl__AlertType)(typeVal) + + var description_ms C.struct_miqt_string = description + description_ret := C.GoStringN(description_ms.data, C.int(int64(description_ms.len))) + C.free(unsafe.Pointer(description_ms.data)) + slotval3 := description_ret + + gofunc(slotval1, slotval2, slotval3) +} + +func (this *QWebSocketServer) AlertReceived(level network.QSsl__AlertLevel, typeVal network.QSsl__AlertType, description string) { + description_ms := C.struct_miqt_string{} + description_ms.data = C.CString(description) + description_ms.len = C.size_t(len(description)) + defer C.free(unsafe.Pointer(description_ms.data)) + C.QWebSocketServer_alertReceived(this.h, (C.int)(level), (C.int)(typeVal), description_ms) +} +func (this *QWebSocketServer) OnAlertReceived(slot func(level network.QSsl__AlertLevel, typeVal network.QSsl__AlertType, description string)) { + C.QWebSocketServer_connect_alertReceived(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_alertReceived +func miqt_exec_callback_QWebSocketServer_alertReceived(cb C.intptr_t, level C.int, typeVal C.int, description C.struct_miqt_string) { + gofunc, ok := cgo.Handle(cb).Value().(func(level network.QSsl__AlertLevel, typeVal network.QSsl__AlertType, description string)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := (network.QSsl__AlertLevel)(level) + + slotval2 := (network.QSsl__AlertType)(typeVal) + + var description_ms C.struct_miqt_string = description + description_ret := C.GoStringN(description_ms.data, C.int(int64(description_ms.len))) + C.free(unsafe.Pointer(description_ms.data)) + slotval3 := description_ret + + gofunc(slotval1, slotval2, slotval3) +} + +func (this *QWebSocketServer) HandshakeInterruptedOnError(error *network.QSslError) { + C.QWebSocketServer_handshakeInterruptedOnError(this.h, (*C.QSslError)(error.UnsafePointer())) +} +func (this *QWebSocketServer) OnHandshakeInterruptedOnError(slot func(error *network.QSslError)) { + C.QWebSocketServer_connect_handshakeInterruptedOnError(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_handshakeInterruptedOnError +func miqt_exec_callback_QWebSocketServer_handshakeInterruptedOnError(cb C.intptr_t, error *C.QSslError) { + gofunc, ok := cgo.Handle(cb).Value().(func(error *network.QSslError)) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + // Convert all CABI parameters to Go parameters + slotval1 := network.UnsafeNewQSslError(unsafe.Pointer(error)) + + gofunc(slotval1) +} + +func (this *QWebSocketServer) Closed() { + C.QWebSocketServer_closed(this.h) +} +func (this *QWebSocketServer) OnClosed(slot func()) { + C.QWebSocketServer_connect_closed(this.h, C.intptr_t(cgo.NewHandle(slot))) +} + +//export miqt_exec_callback_QWebSocketServer_closed +func miqt_exec_callback_QWebSocketServer_closed(cb C.intptr_t) { + gofunc, ok := cgo.Handle(cb).Value().(func()) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + gofunc() +} + +func QWebSocketServer_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.QWebSocketServer_tr2(s_Cstring, c_Cstring) + _ret := C.GoStringN(_ms.data, C.int(int64(_ms.len))) + C.free(unsafe.Pointer(_ms.data)) + return _ret +} + +func QWebSocketServer_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.QWebSocketServer_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 *QWebSocketServer) ListenWithAddress(address *network.QHostAddress) bool { + return (bool)(C.QWebSocketServer_listenWithAddress(this.h, (*C.QHostAddress)(address.UnsafePointer()))) +} + +func (this *QWebSocketServer) Listen2(address *network.QHostAddress, port uint16) bool { + return (bool)(C.QWebSocketServer_listen2(this.h, (*C.QHostAddress)(address.UnsafePointer()), (C.ushort)(port))) +} + +// Sender can only be called from a QWebSocketServer that was directly constructed. +func (this *QWebSocketServer) Sender() *qt6.QObject { + + var _dynamic_cast_ok C.bool = false + _method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QWebSocketServer_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 QWebSocketServer that was directly constructed. +func (this *QWebSocketServer) SenderSignalIndex() int { + + var _dynamic_cast_ok C.bool = false + _method_ret := (int)(C.QWebSocketServer_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 QWebSocketServer that was directly constructed. +func (this *QWebSocketServer) 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.QWebSocketServer_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 QWebSocketServer that was directly constructed. +func (this *QWebSocketServer) IsSignalConnected(signal *qt6.QMetaMethod) bool { + + var _dynamic_cast_ok C.bool = false + _method_ret := (bool)(C.QWebSocketServer_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 *QWebSocketServer) callVirtualBase_NextPendingConnection() *QWebSocket { + + return newQWebSocket(C.QWebSocketServer_virtualbase_nextPendingConnection(unsafe.Pointer(this.h))) + +} +func (this *QWebSocketServer) OnNextPendingConnection(slot func(super func() *QWebSocket) *QWebSocket) { + ok := C.QWebSocketServer_override_virtual_nextPendingConnection(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot))) + if !ok { + panic("miqt: can only override virtual methods for directly constructed types") + } +} + +//export miqt_exec_callback_QWebSocketServer_nextPendingConnection +func miqt_exec_callback_QWebSocketServer_nextPendingConnection(self *C.QWebSocketServer, cb C.intptr_t) *C.QWebSocket { + gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QWebSocket) *QWebSocket) + if !ok { + panic("miqt: callback of non-callback type (heap corruption?)") + } + + virtualReturn := gofunc((&QWebSocketServer{h: self}).callVirtualBase_NextPendingConnection) + + return virtualReturn.cPointer() + +} + +func (this *QWebSocketServer) callVirtualBase_Event(event *qt6.QEvent) bool { + + return (bool)(C.QWebSocketServer_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QWebSocketServer) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) { + ok := C.QWebSocketServer_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_QWebSocketServer_event +func miqt_exec_callback_QWebSocketServer_event(self *C.QWebSocketServer, 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((&QWebSocketServer{h: self}).callVirtualBase_Event, slotval1) + + return (C.bool)(virtualReturn) + +} + +func (this *QWebSocketServer) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool { + + return (bool)(C.QWebSocketServer_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer()))) + +} +func (this *QWebSocketServer) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) { + ok := C.QWebSocketServer_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_QWebSocketServer_eventFilter +func miqt_exec_callback_QWebSocketServer_eventFilter(self *C.QWebSocketServer, 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((&QWebSocketServer{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) + + return (C.bool)(virtualReturn) + +} + +func (this *QWebSocketServer) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) { + + C.QWebSocketServer_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer())) + +} +func (this *QWebSocketServer) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) { + ok := C.QWebSocketServer_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_QWebSocketServer_timerEvent +func miqt_exec_callback_QWebSocketServer_timerEvent(self *C.QWebSocketServer, 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((&QWebSocketServer{h: self}).callVirtualBase_TimerEvent, slotval1) + +} + +func (this *QWebSocketServer) callVirtualBase_ChildEvent(event *qt6.QChildEvent) { + + C.QWebSocketServer_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer())) + +} +func (this *QWebSocketServer) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) { + ok := C.QWebSocketServer_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_QWebSocketServer_childEvent +func miqt_exec_callback_QWebSocketServer_childEvent(self *C.QWebSocketServer, 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((&QWebSocketServer{h: self}).callVirtualBase_ChildEvent, slotval1) + +} + +func (this *QWebSocketServer) callVirtualBase_CustomEvent(event *qt6.QEvent) { + + C.QWebSocketServer_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())) + +} +func (this *QWebSocketServer) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) { + ok := C.QWebSocketServer_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_QWebSocketServer_customEvent +func miqt_exec_callback_QWebSocketServer_customEvent(self *C.QWebSocketServer, 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((&QWebSocketServer{h: self}).callVirtualBase_CustomEvent, slotval1) + +} + +func (this *QWebSocketServer) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) { + + C.QWebSocketServer_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QWebSocketServer) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QWebSocketServer_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_QWebSocketServer_connectNotify +func miqt_exec_callback_QWebSocketServer_connectNotify(self *C.QWebSocketServer, 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((&QWebSocketServer{h: self}).callVirtualBase_ConnectNotify, slotval1) + +} + +func (this *QWebSocketServer) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) { + + C.QWebSocketServer_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())) + +} +func (this *QWebSocketServer) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) { + ok := C.QWebSocketServer_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_QWebSocketServer_disconnectNotify +func miqt_exec_callback_QWebSocketServer_disconnectNotify(self *C.QWebSocketServer, 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((&QWebSocketServer{h: self}).callVirtualBase_DisconnectNotify, slotval1) + +} + +// Delete this object from C++ memory. +func (this *QWebSocketServer) Delete() { + C.QWebSocketServer_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 *QWebSocketServer) GoGC() { + runtime.SetFinalizer(this, func(this *QWebSocketServer) { + this.Delete() + runtime.KeepAlive(this.h) + }) +} diff --git a/qt6/websockets/gen_qwebsocketserver.h b/qt6/websockets/gen_qwebsocketserver.h new file mode 100644 index 000000000..fe7f2d534 --- /dev/null +++ b/qt6/websockets/gen_qwebsocketserver.h @@ -0,0 +1,145 @@ +#pragma once +#ifndef MIQT_QT6_WEBSOCKETS_GEN_QWEBSOCKETSERVER_H +#define MIQT_QT6_WEBSOCKETS_GEN_QWEBSOCKETSERVER_H + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +#include "../../libmiqt/libmiqt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +class QChildEvent; +class QEvent; +class QHostAddress; +class QMetaMethod; +class QMetaObject; +class QNetworkProxy; +class QObject; +class QSslConfiguration; +class QSslError; +class QSslPreSharedKeyAuthenticator; +class QTcpSocket; +class QTimerEvent; +class QUrl; +class QWebSocket; +class QWebSocketCorsAuthenticator; +class QWebSocketServer; +#else +typedef struct QChildEvent QChildEvent; +typedef struct QEvent QEvent; +typedef struct QHostAddress QHostAddress; +typedef struct QMetaMethod QMetaMethod; +typedef struct QMetaObject QMetaObject; +typedef struct QNetworkProxy QNetworkProxy; +typedef struct QObject QObject; +typedef struct QSslConfiguration QSslConfiguration; +typedef struct QSslError QSslError; +typedef struct QSslPreSharedKeyAuthenticator QSslPreSharedKeyAuthenticator; +typedef struct QTcpSocket QTcpSocket; +typedef struct QTimerEvent QTimerEvent; +typedef struct QUrl QUrl; +typedef struct QWebSocket QWebSocket; +typedef struct QWebSocketCorsAuthenticator QWebSocketCorsAuthenticator; +typedef struct QWebSocketServer QWebSocketServer; +#endif + +QWebSocketServer* QWebSocketServer_new(struct miqt_string serverName, int secureMode); +QWebSocketServer* QWebSocketServer_new2(struct miqt_string serverName, int secureMode, QObject* parent); +void QWebSocketServer_virtbase(QWebSocketServer* src, QObject** outptr_QObject); +QMetaObject* QWebSocketServer_metaObject(const QWebSocketServer* self); +void* QWebSocketServer_metacast(QWebSocketServer* self, const char* param1); +struct miqt_string QWebSocketServer_tr(const char* s); +bool QWebSocketServer_listen(QWebSocketServer* self); +void QWebSocketServer_close(QWebSocketServer* self); +bool QWebSocketServer_isListening(const QWebSocketServer* self); +void QWebSocketServer_setMaxPendingConnections(QWebSocketServer* self, int numConnections); +int QWebSocketServer_maxPendingConnections(const QWebSocketServer* self); +void QWebSocketServer_setHandshakeTimeoutWithMsec(QWebSocketServer* self, int msec); +int QWebSocketServer_handshakeTimeoutMS(const QWebSocketServer* self); +unsigned short QWebSocketServer_serverPort(const QWebSocketServer* self); +QHostAddress* QWebSocketServer_serverAddress(const QWebSocketServer* self); +QUrl* QWebSocketServer_serverUrl(const QWebSocketServer* self); +int QWebSocketServer_secureMode(const QWebSocketServer* self); +bool QWebSocketServer_setSocketDescriptor(QWebSocketServer* self, intptr_t socketDescriptor); +intptr_t QWebSocketServer_socketDescriptor(const QWebSocketServer* self); +bool QWebSocketServer_setNativeDescriptor(QWebSocketServer* self, intptr_t descriptor); +intptr_t QWebSocketServer_nativeDescriptor(const QWebSocketServer* self); +bool QWebSocketServer_hasPendingConnections(const QWebSocketServer* self); +QWebSocket* QWebSocketServer_nextPendingConnection(QWebSocketServer* self); +int QWebSocketServer_error(const QWebSocketServer* self); +struct miqt_string QWebSocketServer_errorString(const QWebSocketServer* self); +void QWebSocketServer_pauseAccepting(QWebSocketServer* self); +void QWebSocketServer_resumeAccepting(QWebSocketServer* self); +void QWebSocketServer_setServerName(QWebSocketServer* self, struct miqt_string serverName); +struct miqt_string QWebSocketServer_serverName(const QWebSocketServer* self); +void QWebSocketServer_setSupportedSubprotocols(QWebSocketServer* self, struct miqt_array /* of struct miqt_string */ protocols); +struct miqt_array /* of struct miqt_string */ QWebSocketServer_supportedSubprotocols(const QWebSocketServer* self); +void QWebSocketServer_setProxy(QWebSocketServer* self, QNetworkProxy* networkProxy); +QNetworkProxy* QWebSocketServer_proxy(const QWebSocketServer* self); +void QWebSocketServer_setSslConfiguration(QWebSocketServer* self, QSslConfiguration* sslConfiguration); +QSslConfiguration* QWebSocketServer_sslConfiguration(const QWebSocketServer* self); +struct miqt_array /* of int */ QWebSocketServer_supportedVersions(const QWebSocketServer* self); +void QWebSocketServer_handleConnection(const QWebSocketServer* self, QTcpSocket* socket); +void QWebSocketServer_acceptError(QWebSocketServer* self, int socketError); +void QWebSocketServer_connect_acceptError(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_serverError(QWebSocketServer* self, int closeCode); +void QWebSocketServer_connect_serverError(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_originAuthenticationRequired(QWebSocketServer* self, QWebSocketCorsAuthenticator* pAuthenticator); +void QWebSocketServer_connect_originAuthenticationRequired(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_newConnection(QWebSocketServer* self); +void QWebSocketServer_connect_newConnection(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_peerVerifyError(QWebSocketServer* self, QSslError* error); +void QWebSocketServer_connect_peerVerifyError(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_sslErrors(QWebSocketServer* self, struct miqt_array /* of QSslError* */ errors); +void QWebSocketServer_connect_sslErrors(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_preSharedKeyAuthenticationRequired(QWebSocketServer* self, QSslPreSharedKeyAuthenticator* authenticator); +void QWebSocketServer_connect_preSharedKeyAuthenticationRequired(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_alertSent(QWebSocketServer* self, int level, int type, struct miqt_string description); +void QWebSocketServer_connect_alertSent(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_alertReceived(QWebSocketServer* self, int level, int type, struct miqt_string description); +void QWebSocketServer_connect_alertReceived(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_handshakeInterruptedOnError(QWebSocketServer* self, QSslError* error); +void QWebSocketServer_connect_handshakeInterruptedOnError(QWebSocketServer* self, intptr_t slot); +void QWebSocketServer_closed(QWebSocketServer* self); +void QWebSocketServer_connect_closed(QWebSocketServer* self, intptr_t slot); +struct miqt_string QWebSocketServer_tr2(const char* s, const char* c); +struct miqt_string QWebSocketServer_tr3(const char* s, const char* c, int n); +bool QWebSocketServer_listenWithAddress(QWebSocketServer* self, QHostAddress* address); +bool QWebSocketServer_listen2(QWebSocketServer* self, QHostAddress* address, unsigned short port); + +bool QWebSocketServer_override_virtual_nextPendingConnection(void* self, intptr_t slot); +QWebSocket* QWebSocketServer_virtualbase_nextPendingConnection(void* self); +bool QWebSocketServer_override_virtual_event(void* self, intptr_t slot); +bool QWebSocketServer_virtualbase_event(void* self, QEvent* event); +bool QWebSocketServer_override_virtual_eventFilter(void* self, intptr_t slot); +bool QWebSocketServer_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); +bool QWebSocketServer_override_virtual_timerEvent(void* self, intptr_t slot); +void QWebSocketServer_virtualbase_timerEvent(void* self, QTimerEvent* event); +bool QWebSocketServer_override_virtual_childEvent(void* self, intptr_t slot); +void QWebSocketServer_virtualbase_childEvent(void* self, QChildEvent* event); +bool QWebSocketServer_override_virtual_customEvent(void* self, intptr_t slot); +void QWebSocketServer_virtualbase_customEvent(void* self, QEvent* event); +bool QWebSocketServer_override_virtual_connectNotify(void* self, intptr_t slot); +void QWebSocketServer_virtualbase_connectNotify(void* self, QMetaMethod* signal); +bool QWebSocketServer_override_virtual_disconnectNotify(void* self, intptr_t slot); +void QWebSocketServer_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); + +QObject* QWebSocketServer_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); +int QWebSocketServer_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); +int QWebSocketServer_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); +bool QWebSocketServer_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); + +void QWebSocketServer_delete(QWebSocketServer* self); + +#ifdef __cplusplus +} /* extern C */ +#endif + +#endif From 85d5fe533007b30d4cea861311895b6c69cf6d88 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Mon, 2 Feb 2026 17:28:56 -0500 Subject: [PATCH 3/6] Add Qt 5 WebSockets example --- examples/libraries/qt-websockets/main.go | 166 ++++++++++++++++++ .../libraries/qt-websockets/screenshot.png | Bin 0 -> 21504 bytes 2 files changed, 166 insertions(+) create mode 100644 examples/libraries/qt-websockets/main.go create mode 100644 examples/libraries/qt-websockets/screenshot.png diff --git a/examples/libraries/qt-websockets/main.go b/examples/libraries/qt-websockets/main.go new file mode 100644 index 000000000..cc6fb99af --- /dev/null +++ b/examples/libraries/qt-websockets/main.go @@ -0,0 +1,166 @@ +package main + +import ( + "log" + "os" + "strconv" + "strings" + + "github.com/mappu/miqt/qt" + "github.com/mappu/miqt/qt/network" + "github.com/mappu/miqt/qt/websockets" +) + +const ( + LOCAL_PORT = 12345 + NUM_CLIENTS = 3 + MAX_CLIENTS = 10 + OFFSET_X = 200 +) + +var ( + clients = make(map[int]*websockets.QWebSocket, MAX_CLIENTS) + clientDialogs = make(map[int]*ClientDialog, NUM_CLIENTS) +) + +type ClientDialog struct { + name string + dialog *qt.QDialog + socket *websockets.QWebSocket + messages *qt.QTextEdit + input *qt.QLineEdit + button *qt.QPushButton +} + +func NewClientDialog(name string, clientNumString string) *ClientDialog { + var self ClientDialog + + self.name = clientNumString + + self.dialog = qt.NewQDialog2() + self.dialog.SetWindowTitle(name) + self.dialog.SetMinimumSize2(400, 300) + + self.socket = websockets.NewQWebSocket() + self.socket.SetParent(self.dialog.QWidget.QObject) + + self.messages = qt.NewQTextEdit(self.dialog.QWidget) + self.messages.SetReadOnly(true) + + self.input = qt.NewQLineEdit(self.dialog.QWidget) + self.input.SetPlaceholderText("Enter your message here") + self.input.SetEnabled(false) + + self.button = qt.NewQPushButton5("Send", self.dialog.QWidget) + self.button.SetEnabled(false) + + layout := qt.NewQVBoxLayout2() + inputLayout := qt.NewQHBoxLayout2() + + layout.AddWidget(self.messages.QWidget) + inputLayout.AddWidget(self.input.QWidget) + inputLayout.AddWidget(self.button.QWidget) + layout.AddLayout(inputLayout.QLayout) + self.dialog.SetLayout(layout.QLayout) + + self.socket.OnConnected(func() { + for _, client := range clientDialogs { + if self.socket == client.socket { + self.messages.Append("Connected!") + self.input.SetEnabled(true) + self.button.SetEnabled(true) + self.input.SetFocus() + return + } + } + }) + + self.socket.OnTextMessageReceived(func(message string) { + self.messages.Append(message) + }) + + self.dialog.OnCloseEvent(func(super func(param1 *qt.QCloseEvent), param1 *qt.QCloseEvent) { + for _, client := range clientDialogs { + client.socket.Close() + client.dialog.Delete() + super(param1) + } + }) + + self.button.OnClicked(func() { + message := strings.TrimSpace(self.input.Text()) + if message == "" { + return + } + + self.socket.SendTextMessage("(" + self.name + "): " + message) + self.messages.Append(">> " + message) + self.input.Clear() + }) + + return &self +} + +func (this *ClientDialog) ConnectToServer() { + this.messages.Append("Connecting...") + + url := qt.NewQUrl3("ws://localhost:" + strconv.Itoa(LOCAL_PORT)) + defer url.Delete() + + this.socket.Open(url) +} + +func main() { + qt.NewQApplication(os.Args) + + server := websockets.NewQWebSocketServer("Example Qt WebSockets Server", websockets.QWebSocketServer__NonSecureMode) + defer server.Delete() + + localhost := network.NewQHostAddress8(network.QHostAddress__LocalHostIPv6) + defer localhost.Delete() + + if !server.Listen2(localhost, LOCAL_PORT) { + errorMessage := server.ErrorString() + log.Fatalln("Failed to listen on port " + strconv.Itoa(LOCAL_PORT) + ": " + errorMessage) + } + + for i := 0; i < NUM_CLIENTS; i++ { + numStr := strconv.Itoa(i + 1) + name := "Qt 5 WebSockets Example Client #" + numStr + clientDialogs[i] = NewClientDialog(name, numStr) + + clientDialogs[i].ConnectToServer() + + clientDialogs[i].dialog.Show() + width := clientDialogs[i].dialog.Width() + y := clientDialogs[i].dialog.Y() + clientDialogs[i].dialog.Move(OFFSET_X+(width+10)*i, y) + } + + clientNum := 0 + server.OnNewConnection(func() { + client := server.NextPendingConnection() + if clientNum >= MAX_CLIENTS { + client.Close() + return + } + + clients[clientNum] = client + clientNum++ + + client.OnTextMessageReceived(func(message string) { + for _, c := range clients { + if client == c { + continue + } + c.SendTextMessage(message) + } + }) + + client.OnDisconnected(func() { + client.DeleteLater() + }) + }) + + qt.QApplication_Exec() +} diff --git a/examples/libraries/qt-websockets/screenshot.png b/examples/libraries/qt-websockets/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..b5576fcde4726b02e9a5a43f754565c6e49ba6f8 GIT binary patch literal 21504 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 Date: Mon, 2 Feb 2026 17:29:20 -0500 Subject: [PATCH 4/6] Add Qt 6 WebSockets example --- examples/libraries/qt6-websockets/main.go | 166 ++++++++++++++++++ .../libraries/qt6-websockets/screenshot.png | Bin 0 -> 21073 bytes 2 files changed, 166 insertions(+) create mode 100644 examples/libraries/qt6-websockets/main.go create mode 100644 examples/libraries/qt6-websockets/screenshot.png diff --git a/examples/libraries/qt6-websockets/main.go b/examples/libraries/qt6-websockets/main.go new file mode 100644 index 000000000..b50daa723 --- /dev/null +++ b/examples/libraries/qt6-websockets/main.go @@ -0,0 +1,166 @@ +package main + +import ( + "log" + "os" + "strconv" + "strings" + + qt "github.com/mappu/miqt/qt6" + "github.com/mappu/miqt/qt6/network" + "github.com/mappu/miqt/qt6/websockets" +) + +const ( + LOCAL_PORT = 12345 + NUM_CLIENTS = 3 + MAX_CLIENTS = 10 + OFFSET_X = 200 +) + +var ( + clients = make(map[int]*websockets.QWebSocket, MAX_CLIENTS) + clientDialogs = make(map[int]*ClientDialog, NUM_CLIENTS) +) + +type ClientDialog struct { + name string + dialog *qt.QDialog + socket *websockets.QWebSocket + messages *qt.QTextEdit + input *qt.QLineEdit + button *qt.QPushButton +} + +func NewClientDialog(name string, clientNumString string) *ClientDialog { + var self ClientDialog + + self.name = clientNumString + + self.dialog = qt.NewQDialog2() + self.dialog.SetWindowTitle(name) + self.dialog.SetMinimumSize2(400, 300) + + self.socket = websockets.NewQWebSocket() + self.socket.SetParent(self.dialog.QWidget.QObject) + + self.messages = qt.NewQTextEdit(self.dialog.QWidget) + self.messages.SetReadOnly(true) + + self.input = qt.NewQLineEdit(self.dialog.QWidget) + self.input.SetPlaceholderText("Enter your message here") + self.input.SetEnabled(false) + + self.button = qt.NewQPushButton5("Send", self.dialog.QWidget) + self.button.SetEnabled(false) + + layout := qt.NewQVBoxLayout2() + inputLayout := qt.NewQHBoxLayout2() + + layout.AddWidget(self.messages.QWidget) + inputLayout.AddWidget(self.input.QWidget) + inputLayout.AddWidget(self.button.QWidget) + layout.AddLayout(inputLayout.QLayout) + self.dialog.SetLayout(layout.QLayout) + + self.socket.OnConnected(func() { + for _, client := range clientDialogs { + if self.socket == client.socket { + self.messages.Append("Connected!") + self.input.SetEnabled(true) + self.button.SetEnabled(true) + self.input.SetFocus() + return + } + } + }) + + self.socket.OnTextMessageReceived(func(message string) { + self.messages.Append(message) + }) + + self.dialog.OnCloseEvent(func(super func(param1 *qt.QCloseEvent), param1 *qt.QCloseEvent) { + for _, client := range clientDialogs { + client.socket.Close() + client.dialog.Delete() + super(param1) + } + }) + + self.button.OnClicked(func() { + message := strings.TrimSpace(self.input.Text()) + if message == "" { + return + } + + self.socket.SendTextMessage("(" + self.name + "): " + message) + self.messages.Append(">> " + message) + self.input.Clear() + }) + + return &self +} + +func (this *ClientDialog) ConnectToServer() { + this.messages.Append("Connecting...") + + url := qt.NewQUrl3("ws://localhost:" + strconv.Itoa(LOCAL_PORT)) + defer url.Delete() + + this.socket.Open(url) +} + +func main() { + qt.NewQApplication(os.Args) + + server := websockets.NewQWebSocketServer("Example Qt WebSockets Server", websockets.QWebSocketServer__NonSecureMode) + defer server.Delete() + + localhost := network.NewQHostAddress7(network.QHostAddress__LocalHostIPv6) + defer localhost.Delete() + + if !server.Listen2(localhost, LOCAL_PORT) { + errorMessage := server.ErrorString() + log.Fatalln("Failed to listen on port " + strconv.Itoa(LOCAL_PORT) + ": " + errorMessage) + } + + for i := 0; i < NUM_CLIENTS; i++ { + numStr := strconv.Itoa(i + 1) + name := "Qt 6 WebSockets Example Client #" + numStr + clientDialogs[i] = NewClientDialog(name, numStr) + + clientDialogs[i].ConnectToServer() + + clientDialogs[i].dialog.Show() + width := clientDialogs[i].dialog.Width() + y := clientDialogs[i].dialog.Y() + clientDialogs[i].dialog.Move(OFFSET_X+(width+10)*i, y) + } + + clientNum := 0 + server.OnNewConnection(func() { + client := server.NextPendingConnection() + if clientNum >= MAX_CLIENTS { + client.Close() + return + } + + clients[clientNum] = client + clientNum++ + + client.OnTextMessageReceived(func(message string) { + for _, c := range clients { + if client == c { + continue + } + c.SendTextMessage(message) + } + }) + + client.OnDisconnected(func() { + client.DeleteLater() + }) + }) + + qt.QApplication_Exec() +} diff --git a/examples/libraries/qt6-websockets/screenshot.png b/examples/libraries/qt6-websockets/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..6af95ae9cff39297513bdf4cc97e31323c932702 GIT binary patch literal 21073 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 Ef;Z?+C;$Ke literal 0 HcmV?d00001 From b4b1fab6004f052831822401a4b52ca232991d1f Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Mon, 2 Feb 2026 17:30:30 -0500 Subject: [PATCH 5/6] genbindings.Dockerfile: Add packages for Qt 5/6 WebSockets --- docker/genbindings.Dockerfile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docker/genbindings.Dockerfile b/docker/genbindings.Dockerfile index 0b670a502..6cec6d303 100644 --- a/docker/genbindings.Dockerfile +++ b/docker/genbindings.Dockerfile @@ -11,6 +11,7 @@ RUN DEBIAN_FRONTEND=noninteractive apt-get update && \ qttools5-dev \ libqt5svg5-dev \ libqt5webkit5-dev \ + libqt5websockets5-dev \ qtwebengine5-dev \ qt6-base-dev \ qt6-charts-dev \ @@ -21,6 +22,7 @@ RUN DEBIAN_FRONTEND=noninteractive apt-get update && \ qt6-tools-dev \ qt6-svg-dev \ qt6-webengine-dev \ + qt6-websockets-dev \ libqscintilla2-qt5-dev \ libqscintilla2-qt6-dev \ clang \ From ca484931cae233e6e9463a16055d11579c97ecbf Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Mon, 2 Feb 2026 17:30:55 -0500 Subject: [PATCH 6/6] .gitignore: Update examples --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index a3d7d2caf..b928f6905 100644 --- a/.gitignore +++ b/.gitignore @@ -41,6 +41,7 @@ examples/libraries/qt-svg/qt-svg examples/libraries/qt-uitools/qt-uitools examples/libraries/qt-webengine/qt-webengine examples/libraries/qt-webkit/qt-webkit +examples/libraries/qt-websockets/qt-websockets examples/libraries/qt6-designer/qt6-designer examples/libraries/qt6-multimedia/qt6-multimedia examples/libraries/qt6-network-sctp/qt6-network-sctp @@ -49,6 +50,7 @@ examples/libraries/qt6-pdf/qt6-pdf examples/libraries/qt6-positioning/qt6-positioning examples/libraries/qt6-uitools/qt6-uitools examples/libraries/qt6-webengine/qt6-webengine +examples/libraries/qt6-websockets/qt6-websockets examples/libraries/restricted-extras-charts6/restricted-extras-charts6 examples/libraries/restricted-extras-qscintilla/restricted-extras-qscintilla