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 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{ 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 \ 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 000000000..b5576fcde Binary files /dev/null and b/examples/libraries/qt-websockets/screenshot.png differ 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 000000000..6af95ae9c Binary files /dev/null and b/examples/libraries/qt6-websockets/screenshot.png differ 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