code.ivysaur.me/miqt
1
0
Fork 0
mirror of https://github.com/mappu/miqt.git synced 2024-12-22 00:48:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

qt: rebuild (do not subclass QAbstractEventDispatcher)

Browse Source
This commit is contained in:
mappu 2024-11-23 21:11:35 +13:00
parent 13deba55b7
commit 377addf0b1
6 changed files with 6 additions and 2051 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

568
qt/gen_qabstracteventdispatcher.cpp
View File

@ -2,10 +2,7 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_QAbstractEventDispatcher__TimerInfo #define WORKAROUND_INNER_CLASS_DEFINITION_QAbstractEventDispatcher__TimerInfo
#include <QAbstractNativeEventFilter> #include <QAbstractNativeEventFilter>
#include <QByteArray> #include <QByteArray>
#include <QChildEvent>
#include <QEvent>
#include <QList> #include <QList>
#include <QMetaMethod>
#include <QMetaObject> #include <QMetaObject>
#include <QObject> #include <QObject>
#include <QSocketNotifier> #include <QSocketNotifier>
@ -13,449 +10,10 @@
#include <QByteArray> #include <QByteArray>
#include <cstring> #include <cstring>
#include <QThread> #include <QThread>
#include <QTimerEvent>
#include <qabstracteventdispatcher.h> #include <qabstracteventdispatcher.h>
#include "gen_qabstracteventdispatcher.h" #include "gen_qabstracteventdispatcher.h"
#include "_cgo_export.h" #include "_cgo_export.h"
class MiqtVirtualQAbstractEventDispatcher : public virtual QAbstractEventDispatcher {
public:
MiqtVirtualQAbstractEventDispatcher(): QAbstractEventDispatcher() {};
MiqtVirtualQAbstractEventDispatcher(QObject* parent): QAbstractEventDispatcher(parent) {};
virtual ~MiqtVirtualQAbstractEventDispatcher() = default;
// cgo.Handle value for overwritten implementation
intptr_t handle__ProcessEvents = 0;
// Subclass to allow providing a Go implementation
virtual bool processEvents(QEventLoop::ProcessEventsFlags flags) override {
if (handle__ProcessEvents == 0) {
return false; // Pure virtual, there is no base we can call
}
QEventLoop::ProcessEventsFlags flags_ret = flags;
int sigval1 = static_cast<int>(flags_ret);
bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_ProcessEvents(this, handle__ProcessEvents, sigval1);
return callback_return_value;
}
// cgo.Handle value for overwritten implementation
intptr_t handle__HasPendingEvents = 0;
// Subclass to allow providing a Go implementation
virtual bool hasPendingEvents() override {
if (handle__HasPendingEvents == 0) {
return false; // Pure virtual, there is no base we can call
}
bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_HasPendingEvents(this, handle__HasPendingEvents);
return callback_return_value;
}
// cgo.Handle value for overwritten implementation
intptr_t handle__RegisterSocketNotifier = 0;
// Subclass to allow providing a Go implementation
virtual void registerSocketNotifier(QSocketNotifier* notifier) override {
if (handle__RegisterSocketNotifier == 0) {
return; // Pure virtual, there is no base we can call
}
QSocketNotifier* sigval1 = notifier;
miqt_exec_callback_QAbstractEventDispatcher_RegisterSocketNotifier(this, handle__RegisterSocketNotifier, sigval1);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__UnregisterSocketNotifier = 0;
// Subclass to allow providing a Go implementation
virtual void unregisterSocketNotifier(QSocketNotifier* notifier) override {
if (handle__UnregisterSocketNotifier == 0) {
return; // Pure virtual, there is no base we can call
}
QSocketNotifier* sigval1 = notifier;
miqt_exec_callback_QAbstractEventDispatcher_UnregisterSocketNotifier(this, handle__UnregisterSocketNotifier, sigval1);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__RegisterTimer2 = 0;
// Subclass to allow providing a Go implementation
virtual void registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject* object) override {
if (handle__RegisterTimer2 == 0) {
return; // Pure virtual, there is no base we can call
}
int sigval1 = timerId;
int sigval2 = interval;
Qt::TimerType timerType_ret = timerType;
int sigval3 = static_cast<int>(timerType_ret);
QObject* sigval4 = object;
miqt_exec_callback_QAbstractEventDispatcher_RegisterTimer2(this, handle__RegisterTimer2, sigval1, sigval2, sigval3, sigval4);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__UnregisterTimer = 0;
// Subclass to allow providing a Go implementation
virtual bool unregisterTimer(int timerId) override {
if (handle__UnregisterTimer == 0) {
return false; // Pure virtual, there is no base we can call
}
int sigval1 = timerId;
bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimer(this, handle__UnregisterTimer, sigval1);
return callback_return_value;
}
// cgo.Handle value for overwritten implementation
intptr_t handle__UnregisterTimers = 0;
// Subclass to allow providing a Go implementation
virtual bool unregisterTimers(QObject* object) override {
if (handle__UnregisterTimers == 0) {
return false; // Pure virtual, there is no base we can call
}
QObject* sigval1 = object;
bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimers(this, handle__UnregisterTimers, sigval1);
return callback_return_value;
}
// cgo.Handle value for overwritten implementation
intptr_t handle__RegisteredTimers = 0;
// Subclass to allow providing a Go implementation
virtual QList<QAbstractEventDispatcher::TimerInfo> registeredTimers(QObject* object) const override {
if (handle__RegisteredTimers == 0) {
return QList<QAbstractEventDispatcher::TimerInfo>(); // Pure virtual, there is no base we can call
}
QObject* sigval1 = object;
struct miqt_array /* of QAbstractEventDispatcher__TimerInfo* */ callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_RegisteredTimers(const_cast<MiqtVirtualQAbstractEventDispatcher*>(this), handle__RegisteredTimers, sigval1);
QList<QAbstractEventDispatcher::TimerInfo> callback_return_value_QList;
callback_return_value_QList.reserve(callback_return_value.len);
QAbstractEventDispatcher__TimerInfo** callback_return_value_arr = static_cast<QAbstractEventDispatcher__TimerInfo**>(callback_return_value.data);
for(size_t i = 0; i < callback_return_value.len; ++i) {
callback_return_value_QList.push_back(*(callback_return_value_arr[i]));
}
return callback_return_value_QList;
}
// cgo.Handle value for overwritten implementation
intptr_t handle__RemainingTime = 0;
// Subclass to allow providing a Go implementation
virtual int remainingTime(int timerId) override {
if (handle__RemainingTime == 0) {
return 0; // Pure virtual, there is no base we can call
}
int sigval1 = timerId;
int callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_RemainingTime(this, handle__RemainingTime, sigval1);
return static_cast<int>(callback_return_value);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__WakeUp = 0;
// Subclass to allow providing a Go implementation
virtual void wakeUp() override {
if (handle__WakeUp == 0) {
return; // Pure virtual, there is no base we can call
}
miqt_exec_callback_QAbstractEventDispatcher_WakeUp(this, handle__WakeUp);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__Interrupt = 0;
// Subclass to allow providing a Go implementation
virtual void interrupt() override {
if (handle__Interrupt == 0) {
return; // Pure virtual, there is no base we can call
}
miqt_exec_callback_QAbstractEventDispatcher_Interrupt(this, handle__Interrupt);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__Flush = 0;
// Subclass to allow providing a Go implementation
virtual void flush() override {
if (handle__Flush == 0) {
return; // Pure virtual, there is no base we can call
}
miqt_exec_callback_QAbstractEventDispatcher_Flush(this, handle__Flush);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__StartingUp = 0;
// Subclass to allow providing a Go implementation
virtual void startingUp() override {
if (handle__StartingUp == 0) {
QAbstractEventDispatcher::startingUp();
return;
}
miqt_exec_callback_QAbstractEventDispatcher_StartingUp(this, handle__StartingUp);
}
// Wrapper to allow calling protected method
void virtualbase_StartingUp() {
QAbstractEventDispatcher::startingUp();
}
// cgo.Handle value for overwritten implementation
intptr_t handle__ClosingDown = 0;
// Subclass to allow providing a Go implementation
virtual void closingDown() override {
if (handle__ClosingDown == 0) {
QAbstractEventDispatcher::closingDown();
return;
}
miqt_exec_callback_QAbstractEventDispatcher_ClosingDown(this, handle__ClosingDown);
}
// Wrapper to allow calling protected method
void virtualbase_ClosingDown() {
QAbstractEventDispatcher::closingDown();
}
// 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 QAbstractEventDispatcher::event(event);
}
QEvent* sigval1 = event;
bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_Event(this, handle__Event, sigval1);
return callback_return_value;
}
// Wrapper to allow calling protected method
bool virtualbase_Event(QEvent* event) {
return QAbstractEventDispatcher::event(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 QAbstractEventDispatcher::eventFilter(watched, event);
}
QObject* sigval1 = watched;
QEvent* sigval2 = event;
bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_EventFilter(this, handle__EventFilter, sigval1, sigval2);
return callback_return_value;
}
// Wrapper to allow calling protected method
bool virtualbase_EventFilter(QObject* watched, QEvent* event) {
return QAbstractEventDispatcher::eventFilter(watched, 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) {
QAbstractEventDispatcher::timerEvent(event);
return;
}
QTimerEvent* sigval1 = event;
miqt_exec_callback_QAbstractEventDispatcher_TimerEvent(this, handle__TimerEvent, sigval1);
}
// Wrapper to allow calling protected method
void virtualbase_TimerEvent(QTimerEvent* event) {
QAbstractEventDispatcher::timerEvent(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) {
QAbstractEventDispatcher::childEvent(event);
return;
}
QChildEvent* sigval1 = event;
miqt_exec_callback_QAbstractEventDispatcher_ChildEvent(this, handle__ChildEvent, sigval1);
}
// Wrapper to allow calling protected method
void virtualbase_ChildEvent(QChildEvent* event) {
QAbstractEventDispatcher::childEvent(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) {
QAbstractEventDispatcher::customEvent(event);
return;
}
QEvent* sigval1 = event;
miqt_exec_callback_QAbstractEventDispatcher_CustomEvent(this, handle__CustomEvent, sigval1);
}
// Wrapper to allow calling protected method
void virtualbase_CustomEvent(QEvent* event) {
QAbstractEventDispatcher::customEvent(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) {
QAbstractEventDispatcher::connectNotify(signal);
return;
}
const QMetaMethod& signal_ret = signal;
// Cast returned reference into pointer
QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
miqt_exec_callback_QAbstractEventDispatcher_ConnectNotify(this, handle__ConnectNotify, sigval1);
}
// Wrapper to allow calling protected method
void virtualbase_ConnectNotify(QMetaMethod* signal) {
QAbstractEventDispatcher::connectNotify(*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) {
QAbstractEventDispatcher::disconnectNotify(signal);
return;
}
const QMetaMethod& signal_ret = signal;
// Cast returned reference into pointer
QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
miqt_exec_callback_QAbstractEventDispatcher_DisconnectNotify(this, handle__DisconnectNotify, sigval1);
}
// Wrapper to allow calling protected method
void virtualbase_DisconnectNotify(QMetaMethod* signal) {
QAbstractEventDispatcher::disconnectNotify(*signal);
}
};
void QAbstractEventDispatcher_new(QAbstractEventDispatcher** outptr_QAbstractEventDispatcher, QObject** outptr_QObject) {
MiqtVirtualQAbstractEventDispatcher* ret = new MiqtVirtualQAbstractEventDispatcher();
*outptr_QAbstractEventDispatcher = ret;
*outptr_QObject = static_cast<QObject*>(ret);
}
void QAbstractEventDispatcher_new2(QObject* parent, QAbstractEventDispatcher** outptr_QAbstractEventDispatcher, QObject** outptr_QObject) {
MiqtVirtualQAbstractEventDispatcher* ret = new MiqtVirtualQAbstractEventDispatcher(parent);
*outptr_QAbstractEventDispatcher = ret;
*outptr_QObject = static_cast<QObject*>(ret);
}
QMetaObject* QAbstractEventDispatcher_MetaObject(const QAbstractEventDispatcher* self) { QMetaObject* QAbstractEventDispatcher_MetaObject(const QAbstractEventDispatcher* self) {
return (QMetaObject*) self->metaObject(); return (QMetaObject*) self->metaObject();
} }
@ -577,7 +135,7 @@ void QAbstractEventDispatcher_AboutToBlock(QAbstractEventDispatcher* self) {
} }
void QAbstractEventDispatcher_connect_AboutToBlock(QAbstractEventDispatcher* self, intptr_t slot) { void QAbstractEventDispatcher_connect_AboutToBlock(QAbstractEventDispatcher* self, intptr_t slot) {
MiqtVirtualQAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::aboutToBlock), self, [=]() { QAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::aboutToBlock), self, [=]() {
miqt_exec_callback_QAbstractEventDispatcher_AboutToBlock(slot); miqt_exec_callback_QAbstractEventDispatcher_AboutToBlock(slot);
}); });
} }
@ -587,7 +145,7 @@ void QAbstractEventDispatcher_Awake(QAbstractEventDispatcher* self) {
} }
void QAbstractEventDispatcher_connect_Awake(QAbstractEventDispatcher* self, intptr_t slot) { void QAbstractEventDispatcher_connect_Awake(QAbstractEventDispatcher* self, intptr_t slot) {
MiqtVirtualQAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::awake), self, [=]() { QAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::awake), self, [=]() {
miqt_exec_callback_QAbstractEventDispatcher_Awake(slot); miqt_exec_callback_QAbstractEventDispatcher_Awake(slot);
}); });
} }
@ -640,129 +198,9 @@ QAbstractEventDispatcher* QAbstractEventDispatcher_Instance1(QThread* thread) {
return QAbstractEventDispatcher::instance(thread); return QAbstractEventDispatcher::instance(thread);
} }
void QAbstractEventDispatcher_override_virtual_ProcessEvents(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__ProcessEvents = slot;
}
void QAbstractEventDispatcher_override_virtual_HasPendingEvents(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__HasPendingEvents = slot;
}
void QAbstractEventDispatcher_override_virtual_RegisterSocketNotifier(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__RegisterSocketNotifier = slot;
}
void QAbstractEventDispatcher_override_virtual_UnregisterSocketNotifier(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__UnregisterSocketNotifier = slot;
}
void QAbstractEventDispatcher_override_virtual_RegisterTimer2(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__RegisterTimer2 = slot;
}
void QAbstractEventDispatcher_override_virtual_UnregisterTimer(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__UnregisterTimer = slot;
}
void QAbstractEventDispatcher_override_virtual_UnregisterTimers(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__UnregisterTimers = slot;
}
void QAbstractEventDispatcher_override_virtual_RegisteredTimers(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__RegisteredTimers = slot;
}
void QAbstractEventDispatcher_override_virtual_RemainingTime(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__RemainingTime = slot;
}
void QAbstractEventDispatcher_override_virtual_WakeUp(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__WakeUp = slot;
}
void QAbstractEventDispatcher_override_virtual_Interrupt(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__Interrupt = slot;
}
void QAbstractEventDispatcher_override_virtual_Flush(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__Flush = slot;
}
void QAbstractEventDispatcher_override_virtual_StartingUp(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__StartingUp = slot;
}
void QAbstractEventDispatcher_virtualbase_StartingUp(void* self) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_StartingUp();
}
void QAbstractEventDispatcher_override_virtual_ClosingDown(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__ClosingDown = slot;
}
void QAbstractEventDispatcher_virtualbase_ClosingDown(void* self) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_ClosingDown();
}
void QAbstractEventDispatcher_override_virtual_Event(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__Event = slot;
}
bool QAbstractEventDispatcher_virtualbase_Event(void* self, QEvent* event) {
return ( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_Event(event);
}
void QAbstractEventDispatcher_override_virtual_EventFilter(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__EventFilter = slot;
}
bool QAbstractEventDispatcher_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event) {
return ( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_EventFilter(watched, event);
}
void QAbstractEventDispatcher_override_virtual_TimerEvent(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__TimerEvent = slot;
}
void QAbstractEventDispatcher_virtualbase_TimerEvent(void* self, QTimerEvent* event) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_TimerEvent(event);
}
void QAbstractEventDispatcher_override_virtual_ChildEvent(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__ChildEvent = slot;
}
void QAbstractEventDispatcher_virtualbase_ChildEvent(void* self, QChildEvent* event) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_ChildEvent(event);
}
void QAbstractEventDispatcher_override_virtual_CustomEvent(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__CustomEvent = slot;
}
void QAbstractEventDispatcher_virtualbase_CustomEvent(void* self, QEvent* event) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_CustomEvent(event);
}
void QAbstractEventDispatcher_override_virtual_ConnectNotify(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__ConnectNotify = slot;
}
void QAbstractEventDispatcher_virtualbase_ConnectNotify(void* self, QMetaMethod* signal) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_ConnectNotify(signal);
}
void QAbstractEventDispatcher_override_virtual_DisconnectNotify(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__DisconnectNotify = slot;
}
void QAbstractEventDispatcher_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_DisconnectNotify(signal);
}
void QAbstractEventDispatcher_Delete(QAbstractEventDispatcher* self, bool isSubclass) { void QAbstractEventDispatcher_Delete(QAbstractEventDispatcher* self, bool isSubclass) {
if (isSubclass) { if (isSubclass) {
delete dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( self ); delete dynamic_cast<QAbstractEventDispatcher*>( self );
} else { } else {
delete self; delete self;
} }

444
qt/gen_qabstracteventdispatcher.go
View File

@ -53,28 +53,6 @@ func UnsafeNewQAbstractEventDispatcher(h unsafe.Pointer, h_QObject unsafe.Pointe
QObject: UnsafeNewQObject(h_QObject)} QObject: UnsafeNewQObject(h_QObject)}
} }
// NewQAbstractEventDispatcher constructs a new QAbstractEventDispatcher object.
func NewQAbstractEventDispatcher() *QAbstractEventDispatcher {
var outptr_QAbstractEventDispatcher *C.QAbstractEventDispatcher = nil
var outptr_QObject *C.QObject = nil
C.QAbstractEventDispatcher_new(&outptr_QAbstractEventDispatcher, &outptr_QObject)
ret := newQAbstractEventDispatcher(outptr_QAbstractEventDispatcher, outptr_QObject)
ret.isSubclass = true
return ret
}
// NewQAbstractEventDispatcher2 constructs a new QAbstractEventDispatcher object.
func NewQAbstractEventDispatcher2(parent *QObject) *QAbstractEventDispatcher {
var outptr_QAbstractEventDispatcher *C.QAbstractEventDispatcher = nil
var outptr_QObject *C.QObject = nil
C.QAbstractEventDispatcher_new2(parent.cPointer(), &outptr_QAbstractEventDispatcher, &outptr_QObject)
ret := newQAbstractEventDispatcher(outptr_QAbstractEventDispatcher, outptr_QObject)
ret.isSubclass = true
return ret
}
func (this *QAbstractEventDispatcher) MetaObject() *QMetaObject { func (this *QAbstractEventDispatcher) MetaObject() *QMetaObject {
return UnsafeNewQMetaObject(unsafe.Pointer(C.QAbstractEventDispatcher_MetaObject(this.h))) return UnsafeNewQMetaObject(unsafe.Pointer(C.QAbstractEventDispatcher_MetaObject(this.h)))
} }
@ -272,428 +250,6 @@ func QAbstractEventDispatcher_TrUtf83(s string, c string, n int) string {
func QAbstractEventDispatcher_Instance1(thread *QThread) *QAbstractEventDispatcher { func QAbstractEventDispatcher_Instance1(thread *QThread) *QAbstractEventDispatcher {
return UnsafeNewQAbstractEventDispatcher(unsafe.Pointer(C.QAbstractEventDispatcher_Instance1(thread.cPointer())), nil) return UnsafeNewQAbstractEventDispatcher(unsafe.Pointer(C.QAbstractEventDispatcher_Instance1(thread.cPointer())), nil)
} }
func (this *QAbstractEventDispatcher) OnProcessEvents(slot func(flags QEventLoop__ProcessEventsFlag) bool) {
C.QAbstractEventDispatcher_override_virtual_ProcessEvents(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_ProcessEvents
func miqt_exec_callback_QAbstractEventDispatcher_ProcessEvents(self *C.QAbstractEventDispatcher, cb C.intptr_t, flags C.int) C.bool {
gofunc, ok := cgo.Handle(cb).Value().(func(flags QEventLoop__ProcessEventsFlag) bool)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := (QEventLoop__ProcessEventsFlag)(flags)
virtualReturn := gofunc(slotval1)
return (C.bool)(virtualReturn)
}
func (this *QAbstractEventDispatcher) OnHasPendingEvents(slot func() bool) {
C.QAbstractEventDispatcher_override_virtual_HasPendingEvents(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_HasPendingEvents
func miqt_exec_callback_QAbstractEventDispatcher_HasPendingEvents(self *C.QAbstractEventDispatcher, 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 *QAbstractEventDispatcher) OnRegisterSocketNotifier(slot func(notifier *QSocketNotifier)) {
C.QAbstractEventDispatcher_override_virtual_RegisterSocketNotifier(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_RegisterSocketNotifier
func miqt_exec_callback_QAbstractEventDispatcher_RegisterSocketNotifier(self *C.QAbstractEventDispatcher, cb C.intptr_t, notifier *C.QSocketNotifier) {
gofunc, ok := cgo.Handle(cb).Value().(func(notifier *QSocketNotifier))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQSocketNotifier(unsafe.Pointer(notifier), nil)
gofunc(slotval1)
}
func (this *QAbstractEventDispatcher) OnUnregisterSocketNotifier(slot func(notifier *QSocketNotifier)) {
C.QAbstractEventDispatcher_override_virtual_UnregisterSocketNotifier(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_UnregisterSocketNotifier
func miqt_exec_callback_QAbstractEventDispatcher_UnregisterSocketNotifier(self *C.QAbstractEventDispatcher, cb C.intptr_t, notifier *C.QSocketNotifier) {
gofunc, ok := cgo.Handle(cb).Value().(func(notifier *QSocketNotifier))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQSocketNotifier(unsafe.Pointer(notifier), nil)
gofunc(slotval1)
}
func (this *QAbstractEventDispatcher) OnRegisterTimer2(slot func(timerId int, interval int, timerType TimerType, object *QObject)) {
C.QAbstractEventDispatcher_override_virtual_RegisterTimer2(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_RegisterTimer2
func miqt_exec_callback_QAbstractEventDispatcher_RegisterTimer2(self *C.QAbstractEventDispatcher, cb C.intptr_t, timerId C.int, interval C.int, timerType C.int, object *C.QObject) {
gofunc, ok := cgo.Handle(cb).Value().(func(timerId int, interval int, timerType TimerType, object *QObject))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := (int)(timerId)
slotval2 := (int)(interval)
slotval3 := (TimerType)(timerType)
slotval4 := UnsafeNewQObject(unsafe.Pointer(object))
gofunc(slotval1, slotval2, slotval3, slotval4)
}
func (this *QAbstractEventDispatcher) OnUnregisterTimer(slot func(timerId int) bool) {
C.QAbstractEventDispatcher_override_virtual_UnregisterTimer(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimer
func miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimer(self *C.QAbstractEventDispatcher, cb C.intptr_t, timerId C.int) C.bool {
gofunc, ok := cgo.Handle(cb).Value().(func(timerId int) bool)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := (int)(timerId)
virtualReturn := gofunc(slotval1)
return (C.bool)(virtualReturn)
}
func (this *QAbstractEventDispatcher) OnUnregisterTimers(slot func(object *QObject) bool) {
C.QAbstractEventDispatcher_override_virtual_UnregisterTimers(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimers
func miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimers(self *C.QAbstractEventDispatcher, cb C.intptr_t, object *C.QObject) C.bool {
gofunc, ok := cgo.Handle(cb).Value().(func(object *QObject) bool)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQObject(unsafe.Pointer(object))
virtualReturn := gofunc(slotval1)
return (C.bool)(virtualReturn)
}
func (this *QAbstractEventDispatcher) OnRegisteredTimers(slot func(object *QObject) []QAbstractEventDispatcher__TimerInfo) {
C.QAbstractEventDispatcher_override_virtual_RegisteredTimers(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_RegisteredTimers
func miqt_exec_callback_QAbstractEventDispatcher_RegisteredTimers(self *C.QAbstractEventDispatcher, cb C.intptr_t, object *C.QObject) C.struct_miqt_array {
gofunc, ok := cgo.Handle(cb).Value().(func(object *QObject) []QAbstractEventDispatcher__TimerInfo)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQObject(unsafe.Pointer(object))
virtualReturn := gofunc(slotval1)
virtualReturn_CArray := (*[0xffff]*C.QAbstractEventDispatcher__TimerInfo)(C.malloc(C.size_t(8 * len(virtualReturn))))
defer C.free(unsafe.Pointer(virtualReturn_CArray))
for i := range virtualReturn {
virtualReturn_CArray[i] = virtualReturn[i].cPointer()
}
virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)}
return virtualReturn_ma
}
func (this *QAbstractEventDispatcher) OnRemainingTime(slot func(timerId int) int) {
C.QAbstractEventDispatcher_override_virtual_RemainingTime(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_RemainingTime
func miqt_exec_callback_QAbstractEventDispatcher_RemainingTime(self *C.QAbstractEventDispatcher, cb C.intptr_t, timerId C.int) C.int {
gofunc, ok := cgo.Handle(cb).Value().(func(timerId int) int)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := (int)(timerId)
virtualReturn := gofunc(slotval1)
return (C.int)(virtualReturn)
}
func (this *QAbstractEventDispatcher) OnWakeUp(slot func()) {
C.QAbstractEventDispatcher_override_virtual_WakeUp(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_WakeUp
func miqt_exec_callback_QAbstractEventDispatcher_WakeUp(self *C.QAbstractEventDispatcher, 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 *QAbstractEventDispatcher) OnInterrupt(slot func()) {
C.QAbstractEventDispatcher_override_virtual_Interrupt(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_Interrupt
func miqt_exec_callback_QAbstractEventDispatcher_Interrupt(self *C.QAbstractEventDispatcher, 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 *QAbstractEventDispatcher) OnFlush(slot func()) {
C.QAbstractEventDispatcher_override_virtual_Flush(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_Flush
func miqt_exec_callback_QAbstractEventDispatcher_Flush(self *C.QAbstractEventDispatcher, 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 *QAbstractEventDispatcher) callVirtualBase_StartingUp() {
C.QAbstractEventDispatcher_virtualbase_StartingUp(unsafe.Pointer(this.h))
}
func (this *QAbstractEventDispatcher) OnStartingUp(slot func(super func())) {
C.QAbstractEventDispatcher_override_virtual_StartingUp(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_StartingUp
func miqt_exec_callback_QAbstractEventDispatcher_StartingUp(self *C.QAbstractEventDispatcher, cb C.intptr_t) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func()))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_StartingUp)
}
func (this *QAbstractEventDispatcher) callVirtualBase_ClosingDown() {
C.QAbstractEventDispatcher_virtualbase_ClosingDown(unsafe.Pointer(this.h))
}
func (this *QAbstractEventDispatcher) OnClosingDown(slot func(super func())) {
C.QAbstractEventDispatcher_override_virtual_ClosingDown(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_ClosingDown
func miqt_exec_callback_QAbstractEventDispatcher_ClosingDown(self *C.QAbstractEventDispatcher, cb C.intptr_t) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func()))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_ClosingDown)
}
func (this *QAbstractEventDispatcher) callVirtualBase_Event(event *QEvent) bool {
return (bool)(C.QAbstractEventDispatcher_virtualbase_Event(unsafe.Pointer(this.h), event.cPointer()))
}
func (this *QAbstractEventDispatcher) OnEvent(slot func(super func(event *QEvent) bool, event *QEvent) bool) {
C.QAbstractEventDispatcher_override_virtual_Event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_Event
func miqt_exec_callback_QAbstractEventDispatcher_Event(self *C.QAbstractEventDispatcher, cb C.intptr_t, event *C.QEvent) C.bool {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent) bool, event *QEvent) bool)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQEvent(unsafe.Pointer(event))
virtualReturn := gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_Event, slotval1)
return (C.bool)(virtualReturn)
}
func (this *QAbstractEventDispatcher) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool {
return (bool)(C.QAbstractEventDispatcher_virtualbase_EventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer()))
}
func (this *QAbstractEventDispatcher) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) {
C.QAbstractEventDispatcher_override_virtual_EventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_EventFilter
func miqt_exec_callback_QAbstractEventDispatcher_EventFilter(self *C.QAbstractEventDispatcher, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQObject(unsafe.Pointer(watched))
slotval2 := UnsafeNewQEvent(unsafe.Pointer(event))
virtualReturn := gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
return (C.bool)(virtualReturn)
}
func (this *QAbstractEventDispatcher) callVirtualBase_TimerEvent(event *QTimerEvent) {
C.QAbstractEventDispatcher_virtualbase_TimerEvent(unsafe.Pointer(this.h), event.cPointer())
}
func (this *QAbstractEventDispatcher) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) {
C.QAbstractEventDispatcher_override_virtual_TimerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_TimerEvent
func miqt_exec_callback_QAbstractEventDispatcher_TimerEvent(self *C.QAbstractEventDispatcher, cb C.intptr_t, event *C.QTimerEvent) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QTimerEvent), event *QTimerEvent))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQTimerEvent(unsafe.Pointer(event), nil)
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_TimerEvent, slotval1)
}
func (this *QAbstractEventDispatcher) callVirtualBase_ChildEvent(event *QChildEvent) {
C.QAbstractEventDispatcher_virtualbase_ChildEvent(unsafe.Pointer(this.h), event.cPointer())
}
func (this *QAbstractEventDispatcher) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) {
C.QAbstractEventDispatcher_override_virtual_ChildEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_ChildEvent
func miqt_exec_callback_QAbstractEventDispatcher_ChildEvent(self *C.QAbstractEventDispatcher, cb C.intptr_t, event *C.QChildEvent) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QChildEvent), event *QChildEvent))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQChildEvent(unsafe.Pointer(event), nil)
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_ChildEvent, slotval1)
}
func (this *QAbstractEventDispatcher) callVirtualBase_CustomEvent(event *QEvent) {
C.QAbstractEventDispatcher_virtualbase_CustomEvent(unsafe.Pointer(this.h), event.cPointer())
}
func (this *QAbstractEventDispatcher) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) {
C.QAbstractEventDispatcher_override_virtual_CustomEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_CustomEvent
func miqt_exec_callback_QAbstractEventDispatcher_CustomEvent(self *C.QAbstractEventDispatcher, cb C.intptr_t, event *C.QEvent) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent), event *QEvent))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQEvent(unsafe.Pointer(event))
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_CustomEvent, slotval1)
}
func (this *QAbstractEventDispatcher) callVirtualBase_ConnectNotify(signal *QMetaMethod) {
C.QAbstractEventDispatcher_virtualbase_ConnectNotify(unsafe.Pointer(this.h), signal.cPointer())
}
func (this *QAbstractEventDispatcher) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
C.QAbstractEventDispatcher_override_virtual_ConnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_ConnectNotify
func miqt_exec_callback_QAbstractEventDispatcher_ConnectNotify(self *C.QAbstractEventDispatcher, cb C.intptr_t, signal *C.QMetaMethod) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *QMetaMethod), signal *QMetaMethod))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQMetaMethod(unsafe.Pointer(signal))
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_ConnectNotify, slotval1)
}
func (this *QAbstractEventDispatcher) callVirtualBase_DisconnectNotify(signal *QMetaMethod) {
C.QAbstractEventDispatcher_virtualbase_DisconnectNotify(unsafe.Pointer(this.h), signal.cPointer())
}
func (this *QAbstractEventDispatcher) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
C.QAbstractEventDispatcher_override_virtual_DisconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_DisconnectNotify
func miqt_exec_callback_QAbstractEventDispatcher_DisconnectNotify(self *C.QAbstractEventDispatcher, cb C.intptr_t, signal *C.QMetaMethod) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *QMetaMethod), signal *QMetaMethod))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQMetaMethod(unsafe.Pointer(signal))
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_DisconnectNotify, slotval1)
}
// Delete this object from C++ memory. // Delete this object from C++ memory.
func (this *QAbstractEventDispatcher) Delete() { func (this *QAbstractEventDispatcher) Delete() {

52
qt/gen_qabstracteventdispatcher.h
View File

@ -23,31 +23,21 @@ class QAbstractEventDispatcher__TimerInfo;
#endif #endif
class QAbstractNativeEventFilter; class QAbstractNativeEventFilter;
class QByteArray; class QByteArray;
class QChildEvent;
class QEvent;
class QMetaMethod;
class QMetaObject; class QMetaObject;
class QObject; class QObject;
class QSocketNotifier; class QSocketNotifier;
class QThread; class QThread;
class QTimerEvent;
#else #else
typedef struct QAbstractEventDispatcher QAbstractEventDispatcher; typedef struct QAbstractEventDispatcher QAbstractEventDispatcher;
typedef struct QAbstractEventDispatcher__TimerInfo QAbstractEventDispatcher__TimerInfo; typedef struct QAbstractEventDispatcher__TimerInfo QAbstractEventDispatcher__TimerInfo;
typedef struct QAbstractNativeEventFilter QAbstractNativeEventFilter; typedef struct QAbstractNativeEventFilter QAbstractNativeEventFilter;
typedef struct QByteArray QByteArray; typedef struct QByteArray QByteArray;
typedef struct QChildEvent QChildEvent;
typedef struct QEvent QEvent;
typedef struct QMetaMethod QMetaMethod;
typedef struct QMetaObject QMetaObject; typedef struct QMetaObject QMetaObject;
typedef struct QObject QObject; typedef struct QObject QObject;
typedef struct QSocketNotifier QSocketNotifier; typedef struct QSocketNotifier QSocketNotifier;
typedef struct QThread QThread; typedef struct QThread QThread;
typedef struct QTimerEvent QTimerEvent;
#endif #endif
void QAbstractEventDispatcher_new(QAbstractEventDispatcher** outptr_QAbstractEventDispatcher, QObject** outptr_QObject);
void QAbstractEventDispatcher_new2(QObject* parent, QAbstractEventDispatcher** outptr_QAbstractEventDispatcher, QObject** outptr_QObject);
QMetaObject* QAbstractEventDispatcher_MetaObject(const QAbstractEventDispatcher* self); QMetaObject* QAbstractEventDispatcher_MetaObject(const QAbstractEventDispatcher* self);
void* QAbstractEventDispatcher_Metacast(QAbstractEventDispatcher* self, const char* param1); void* QAbstractEventDispatcher_Metacast(QAbstractEventDispatcher* self, const char* param1);
struct miqt_string QAbstractEventDispatcher_Tr(const char* s); struct miqt_string QAbstractEventDispatcher_Tr(const char* s);
@ -80,48 +70,6 @@ struct miqt_string QAbstractEventDispatcher_Tr3(const char* s, const char* c, in
struct miqt_string QAbstractEventDispatcher_TrUtf82(const char* s, const char* c); struct miqt_string QAbstractEventDispatcher_TrUtf82(const char* s, const char* c);
struct miqt_string QAbstractEventDispatcher_TrUtf83(const char* s, const char* c, int n); struct miqt_string QAbstractEventDispatcher_TrUtf83(const char* s, const char* c, int n);
QAbstractEventDispatcher* QAbstractEventDispatcher_Instance1(QThread* thread); QAbstractEventDispatcher* QAbstractEventDispatcher_Instance1(QThread* thread);
void QAbstractEventDispatcher_override_virtual_ProcessEvents(void* self, intptr_t slot);
bool QAbstractEventDispatcher_virtualbase_ProcessEvents(void* self, int flags);
void QAbstractEventDispatcher_override_virtual_HasPendingEvents(void* self, intptr_t slot);
bool QAbstractEventDispatcher_virtualbase_HasPendingEvents(void* self);
void QAbstractEventDispatcher_override_virtual_RegisterSocketNotifier(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_RegisterSocketNotifier(void* self, QSocketNotifier* notifier);
void QAbstractEventDispatcher_override_virtual_UnregisterSocketNotifier(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_UnregisterSocketNotifier(void* self, QSocketNotifier* notifier);
void QAbstractEventDispatcher_override_virtual_RegisterTimer2(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_RegisterTimer2(void* self, int timerId, int interval, int timerType, QObject* object);
void QAbstractEventDispatcher_override_virtual_UnregisterTimer(void* self, intptr_t slot);
bool QAbstractEventDispatcher_virtualbase_UnregisterTimer(void* self, int timerId);
void QAbstractEventDispatcher_override_virtual_UnregisterTimers(void* self, intptr_t slot);
bool QAbstractEventDispatcher_virtualbase_UnregisterTimers(void* self, QObject* object);
void QAbstractEventDispatcher_override_virtual_RegisteredTimers(void* self, intptr_t slot);
struct miqt_array /* of QAbstractEventDispatcher__TimerInfo* */ QAbstractEventDispatcher_virtualbase_RegisteredTimers(const void* self, QObject* object);
void QAbstractEventDispatcher_override_virtual_RemainingTime(void* self, intptr_t slot);
int QAbstractEventDispatcher_virtualbase_RemainingTime(void* self, int timerId);
void QAbstractEventDispatcher_override_virtual_WakeUp(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_WakeUp(void* self);
void QAbstractEventDispatcher_override_virtual_Interrupt(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_Interrupt(void* self);
void QAbstractEventDispatcher_override_virtual_Flush(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_Flush(void* self);
void QAbstractEventDispatcher_override_virtual_StartingUp(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_StartingUp(void* self);
void QAbstractEventDispatcher_override_virtual_ClosingDown(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_ClosingDown(void* self);
void QAbstractEventDispatcher_override_virtual_Event(void* self, intptr_t slot);
bool QAbstractEventDispatcher_virtualbase_Event(void* self, QEvent* event);
void QAbstractEventDispatcher_override_virtual_EventFilter(void* self, intptr_t slot);
bool QAbstractEventDispatcher_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event);
void QAbstractEventDispatcher_override_virtual_TimerEvent(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_TimerEvent(void* self, QTimerEvent* event);
void QAbstractEventDispatcher_override_virtual_ChildEvent(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_ChildEvent(void* self, QChildEvent* event);
void QAbstractEventDispatcher_override_virtual_CustomEvent(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_CustomEvent(void* self, QEvent* event);
void QAbstractEventDispatcher_override_virtual_ConnectNotify(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_ConnectNotify(void* self, QMetaMethod* signal);
void QAbstractEventDispatcher_override_virtual_DisconnectNotify(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal);
void QAbstractEventDispatcher_Delete(QAbstractEventDispatcher* self, bool isSubclass); void QAbstractEventDispatcher_Delete(QAbstractEventDispatcher* self, bool isSubclass);
void QAbstractEventDispatcher__TimerInfo_new(int id, int i, int t, QAbstractEventDispatcher__TimerInfo** outptr_QAbstractEventDispatcher__TimerInfo); void QAbstractEventDispatcher__TimerInfo_new(int id, int i, int t, QAbstractEventDispatcher__TimerInfo** outptr_QAbstractEventDispatcher__TimerInfo);

531
qt6/gen_qabstracteventdispatcher.cpp
View File

@ -2,10 +2,7 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_QAbstractEventDispatcher__TimerInfo #define WORKAROUND_INNER_CLASS_DEFINITION_QAbstractEventDispatcher__TimerInfo
#include <QAbstractNativeEventFilter> #include <QAbstractNativeEventFilter>
#include <QByteArray> #include <QByteArray>
#include <QChildEvent>
#include <QEvent>
#include <QList> #include <QList>
#include <QMetaMethod>
#include <QMetaObject> #include <QMetaObject>
#include <QObject> #include <QObject>
#include <QSocketNotifier> #include <QSocketNotifier>
@ -13,420 +10,10 @@
#include <QByteArray> #include <QByteArray>
#include <cstring> #include <cstring>
#include <QThread> #include <QThread>
#include <QTimerEvent>
#include <qabstracteventdispatcher.h> #include <qabstracteventdispatcher.h>
#include "gen_qabstracteventdispatcher.h" #include "gen_qabstracteventdispatcher.h"
#include "_cgo_export.h" #include "_cgo_export.h"
class MiqtVirtualQAbstractEventDispatcher : public virtual QAbstractEventDispatcher {
public:
MiqtVirtualQAbstractEventDispatcher(): QAbstractEventDispatcher() {};
MiqtVirtualQAbstractEventDispatcher(QObject* parent): QAbstractEventDispatcher(parent) {};
virtual ~MiqtVirtualQAbstractEventDispatcher() = default;
// cgo.Handle value for overwritten implementation
intptr_t handle__ProcessEvents = 0;
// Subclass to allow providing a Go implementation
virtual bool processEvents(QEventLoop::ProcessEventsFlags flags) override {
if (handle__ProcessEvents == 0) {
return false; // Pure virtual, there is no base we can call
}
QEventLoop::ProcessEventsFlags flags_ret = flags;
int sigval1 = static_cast<int>(flags_ret);
bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_ProcessEvents(this, handle__ProcessEvents, sigval1);
return callback_return_value;
}
// cgo.Handle value for overwritten implementation
intptr_t handle__RegisterSocketNotifier = 0;
// Subclass to allow providing a Go implementation
virtual void registerSocketNotifier(QSocketNotifier* notifier) override {
if (handle__RegisterSocketNotifier == 0) {
return; // Pure virtual, there is no base we can call
}
QSocketNotifier* sigval1 = notifier;
miqt_exec_callback_QAbstractEventDispatcher_RegisterSocketNotifier(this, handle__RegisterSocketNotifier, sigval1);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__UnregisterSocketNotifier = 0;
// Subclass to allow providing a Go implementation
virtual void unregisterSocketNotifier(QSocketNotifier* notifier) override {
if (handle__UnregisterSocketNotifier == 0) {
return; // Pure virtual, there is no base we can call
}
QSocketNotifier* sigval1 = notifier;
miqt_exec_callback_QAbstractEventDispatcher_UnregisterSocketNotifier(this, handle__UnregisterSocketNotifier, sigval1);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__RegisterTimer2 = 0;
// Subclass to allow providing a Go implementation
virtual void registerTimer(int timerId, qint64 interval, Qt::TimerType timerType, QObject* object) override {
if (handle__RegisterTimer2 == 0) {
return; // Pure virtual, there is no base we can call
}
int sigval1 = timerId;
qint64 interval_ret = interval;
long long sigval2 = static_cast<long long>(interval_ret);
Qt::TimerType timerType_ret = timerType;
int sigval3 = static_cast<int>(timerType_ret);
QObject* sigval4 = object;
miqt_exec_callback_QAbstractEventDispatcher_RegisterTimer2(this, handle__RegisterTimer2, sigval1, sigval2, sigval3, sigval4);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__UnregisterTimer = 0;
// Subclass to allow providing a Go implementation
virtual bool unregisterTimer(int timerId) override {
if (handle__UnregisterTimer == 0) {
return false; // Pure virtual, there is no base we can call
}
int sigval1 = timerId;
bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimer(this, handle__UnregisterTimer, sigval1);
return callback_return_value;
}
// cgo.Handle value for overwritten implementation
intptr_t handle__UnregisterTimers = 0;
// Subclass to allow providing a Go implementation
virtual bool unregisterTimers(QObject* object) override {
if (handle__UnregisterTimers == 0) {
return false; // Pure virtual, there is no base we can call
}
QObject* sigval1 = object;
bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimers(this, handle__UnregisterTimers, sigval1);
return callback_return_value;
}
// cgo.Handle value for overwritten implementation
intptr_t handle__RegisteredTimers = 0;
// Subclass to allow providing a Go implementation
virtual QList<QAbstractEventDispatcher::TimerInfo> registeredTimers(QObject* object) const override {
if (handle__RegisteredTimers == 0) {
return QList<QAbstractEventDispatcher::TimerInfo>(); // Pure virtual, there is no base we can call
}
QObject* sigval1 = object;
struct miqt_array /* of QAbstractEventDispatcher__TimerInfo* */ callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_RegisteredTimers(const_cast<MiqtVirtualQAbstractEventDispatcher*>(this), handle__RegisteredTimers, sigval1);
QList<QAbstractEventDispatcher::TimerInfo> callback_return_value_QList;
callback_return_value_QList.reserve(callback_return_value.len);
QAbstractEventDispatcher__TimerInfo** callback_return_value_arr = static_cast<QAbstractEventDispatcher__TimerInfo**>(callback_return_value.data);
for(size_t i = 0; i < callback_return_value.len; ++i) {
callback_return_value_QList.push_back(*(callback_return_value_arr[i]));
}
return callback_return_value_QList;
}
// cgo.Handle value for overwritten implementation
intptr_t handle__RemainingTime = 0;
// Subclass to allow providing a Go implementation
virtual int remainingTime(int timerId) override {
if (handle__RemainingTime == 0) {
return 0; // Pure virtual, there is no base we can call
}
int sigval1 = timerId;
int callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_RemainingTime(this, handle__RemainingTime, sigval1);
return static_cast<int>(callback_return_value);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__WakeUp = 0;
// Subclass to allow providing a Go implementation
virtual void wakeUp() override {
if (handle__WakeUp == 0) {
return; // Pure virtual, there is no base we can call
}
miqt_exec_callback_QAbstractEventDispatcher_WakeUp(this, handle__WakeUp);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__Interrupt = 0;
// Subclass to allow providing a Go implementation
virtual void interrupt() override {
if (handle__Interrupt == 0) {
return; // Pure virtual, there is no base we can call
}
miqt_exec_callback_QAbstractEventDispatcher_Interrupt(this, handle__Interrupt);
}
// cgo.Handle value for overwritten implementation
intptr_t handle__StartingUp = 0;
// Subclass to allow providing a Go implementation
virtual void startingUp() override {
if (handle__StartingUp == 0) {
QAbstractEventDispatcher::startingUp();
return;
}
miqt_exec_callback_QAbstractEventDispatcher_StartingUp(this, handle__StartingUp);
}
// Wrapper to allow calling protected method
void virtualbase_StartingUp() {
QAbstractEventDispatcher::startingUp();
}
// cgo.Handle value for overwritten implementation
intptr_t handle__ClosingDown = 0;
// Subclass to allow providing a Go implementation
virtual void closingDown() override {
if (handle__ClosingDown == 0) {
QAbstractEventDispatcher::closingDown();
return;
}
miqt_exec_callback_QAbstractEventDispatcher_ClosingDown(this, handle__ClosingDown);
}
// Wrapper to allow calling protected method
void virtualbase_ClosingDown() {
QAbstractEventDispatcher::closingDown();
}
// 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 QAbstractEventDispatcher::event(event);
}
QEvent* sigval1 = event;
bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_Event(this, handle__Event, sigval1);
return callback_return_value;
}
// Wrapper to allow calling protected method
bool virtualbase_Event(QEvent* event) {
return QAbstractEventDispatcher::event(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 QAbstractEventDispatcher::eventFilter(watched, event);
}
QObject* sigval1 = watched;
QEvent* sigval2 = event;
bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_EventFilter(this, handle__EventFilter, sigval1, sigval2);
return callback_return_value;
}
// Wrapper to allow calling protected method
bool virtualbase_EventFilter(QObject* watched, QEvent* event) {
return QAbstractEventDispatcher::eventFilter(watched, 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) {
QAbstractEventDispatcher::timerEvent(event);
return;
}
QTimerEvent* sigval1 = event;
miqt_exec_callback_QAbstractEventDispatcher_TimerEvent(this, handle__TimerEvent, sigval1);
}
// Wrapper to allow calling protected method
void virtualbase_TimerEvent(QTimerEvent* event) {
QAbstractEventDispatcher::timerEvent(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) {
QAbstractEventDispatcher::childEvent(event);
return;
}
QChildEvent* sigval1 = event;
miqt_exec_callback_QAbstractEventDispatcher_ChildEvent(this, handle__ChildEvent, sigval1);
}
// Wrapper to allow calling protected method
void virtualbase_ChildEvent(QChildEvent* event) {
QAbstractEventDispatcher::childEvent(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) {
QAbstractEventDispatcher::customEvent(event);
return;
}
QEvent* sigval1 = event;
miqt_exec_callback_QAbstractEventDispatcher_CustomEvent(this, handle__CustomEvent, sigval1);
}
// Wrapper to allow calling protected method
void virtualbase_CustomEvent(QEvent* event) {
QAbstractEventDispatcher::customEvent(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) {
QAbstractEventDispatcher::connectNotify(signal);
return;
}
const QMetaMethod& signal_ret = signal;
// Cast returned reference into pointer
QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
miqt_exec_callback_QAbstractEventDispatcher_ConnectNotify(this, handle__ConnectNotify, sigval1);
}
// Wrapper to allow calling protected method
void virtualbase_ConnectNotify(QMetaMethod* signal) {
QAbstractEventDispatcher::connectNotify(*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) {
QAbstractEventDispatcher::disconnectNotify(signal);
return;
}
const QMetaMethod& signal_ret = signal;
// Cast returned reference into pointer
QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
miqt_exec_callback_QAbstractEventDispatcher_DisconnectNotify(this, handle__DisconnectNotify, sigval1);
}
// Wrapper to allow calling protected method
void virtualbase_DisconnectNotify(QMetaMethod* signal) {
QAbstractEventDispatcher::disconnectNotify(*signal);
}
};
void QAbstractEventDispatcher_new(QAbstractEventDispatcher** outptr_QAbstractEventDispatcher, QObject** outptr_QObject) {
MiqtVirtualQAbstractEventDispatcher* ret = new MiqtVirtualQAbstractEventDispatcher();
*outptr_QAbstractEventDispatcher = ret;
*outptr_QObject = static_cast<QObject*>(ret);
}
void QAbstractEventDispatcher_new2(QObject* parent, QAbstractEventDispatcher** outptr_QAbstractEventDispatcher, QObject** outptr_QObject) {
MiqtVirtualQAbstractEventDispatcher* ret = new MiqtVirtualQAbstractEventDispatcher(parent);
*outptr_QAbstractEventDispatcher = ret;
*outptr_QObject = static_cast<QObject*>(ret);
}
QMetaObject* QAbstractEventDispatcher_MetaObject(const QAbstractEventDispatcher* self) { QMetaObject* QAbstractEventDispatcher_MetaObject(const QAbstractEventDispatcher* self) {
return (QMetaObject*) self->metaObject(); return (QMetaObject*) self->metaObject();
} }
@ -529,7 +116,7 @@ void QAbstractEventDispatcher_AboutToBlock(QAbstractEventDispatcher* self) {
} }
void QAbstractEventDispatcher_connect_AboutToBlock(QAbstractEventDispatcher* self, intptr_t slot) { void QAbstractEventDispatcher_connect_AboutToBlock(QAbstractEventDispatcher* self, intptr_t slot) {
MiqtVirtualQAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::aboutToBlock), self, [=]() { QAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::aboutToBlock), self, [=]() {
miqt_exec_callback_QAbstractEventDispatcher_AboutToBlock(slot); miqt_exec_callback_QAbstractEventDispatcher_AboutToBlock(slot);
}); });
} }
@ -539,7 +126,7 @@ void QAbstractEventDispatcher_Awake(QAbstractEventDispatcher* self) {
} }
void QAbstractEventDispatcher_connect_Awake(QAbstractEventDispatcher* self, intptr_t slot) { void QAbstractEventDispatcher_connect_Awake(QAbstractEventDispatcher* self, intptr_t slot) {
MiqtVirtualQAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::awake), self, [=]() { QAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::awake), self, [=]() {
miqt_exec_callback_QAbstractEventDispatcher_Awake(slot); miqt_exec_callback_QAbstractEventDispatcher_Awake(slot);
}); });
} }
@ -570,121 +157,9 @@ QAbstractEventDispatcher* QAbstractEventDispatcher_Instance1(QThread* thread) {
return QAbstractEventDispatcher::instance(thread); return QAbstractEventDispatcher::instance(thread);
} }
void QAbstractEventDispatcher_override_virtual_ProcessEvents(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__ProcessEvents = slot;
}
void QAbstractEventDispatcher_override_virtual_RegisterSocketNotifier(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__RegisterSocketNotifier = slot;
}
void QAbstractEventDispatcher_override_virtual_UnregisterSocketNotifier(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__UnregisterSocketNotifier = slot;
}
void QAbstractEventDispatcher_override_virtual_RegisterTimer2(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__RegisterTimer2 = slot;
}
void QAbstractEventDispatcher_override_virtual_UnregisterTimer(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__UnregisterTimer = slot;
}
void QAbstractEventDispatcher_override_virtual_UnregisterTimers(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__UnregisterTimers = slot;
}
void QAbstractEventDispatcher_override_virtual_RegisteredTimers(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__RegisteredTimers = slot;
}
void QAbstractEventDispatcher_override_virtual_RemainingTime(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__RemainingTime = slot;
}
void QAbstractEventDispatcher_override_virtual_WakeUp(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__WakeUp = slot;
}
void QAbstractEventDispatcher_override_virtual_Interrupt(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__Interrupt = slot;
}
void QAbstractEventDispatcher_override_virtual_StartingUp(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__StartingUp = slot;
}
void QAbstractEventDispatcher_virtualbase_StartingUp(void* self) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_StartingUp();
}
void QAbstractEventDispatcher_override_virtual_ClosingDown(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__ClosingDown = slot;
}
void QAbstractEventDispatcher_virtualbase_ClosingDown(void* self) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_ClosingDown();
}
void QAbstractEventDispatcher_override_virtual_Event(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__Event = slot;
}
bool QAbstractEventDispatcher_virtualbase_Event(void* self, QEvent* event) {
return ( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_Event(event);
}
void QAbstractEventDispatcher_override_virtual_EventFilter(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__EventFilter = slot;
}
bool QAbstractEventDispatcher_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event) {
return ( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_EventFilter(watched, event);
}
void QAbstractEventDispatcher_override_virtual_TimerEvent(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__TimerEvent = slot;
}
void QAbstractEventDispatcher_virtualbase_TimerEvent(void* self, QTimerEvent* event) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_TimerEvent(event);
}
void QAbstractEventDispatcher_override_virtual_ChildEvent(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__ChildEvent = slot;
}
void QAbstractEventDispatcher_virtualbase_ChildEvent(void* self, QChildEvent* event) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_ChildEvent(event);
}
void QAbstractEventDispatcher_override_virtual_CustomEvent(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__CustomEvent = slot;
}
void QAbstractEventDispatcher_virtualbase_CustomEvent(void* self, QEvent* event) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_CustomEvent(event);
}
void QAbstractEventDispatcher_override_virtual_ConnectNotify(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__ConnectNotify = slot;
}
void QAbstractEventDispatcher_virtualbase_ConnectNotify(void* self, QMetaMethod* signal) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_ConnectNotify(signal);
}
void QAbstractEventDispatcher_override_virtual_DisconnectNotify(void* self, intptr_t slot) {
dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__DisconnectNotify = slot;
}
void QAbstractEventDispatcher_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal) {
( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_DisconnectNotify(signal);
}
void QAbstractEventDispatcher_Delete(QAbstractEventDispatcher* self, bool isSubclass) { void QAbstractEventDispatcher_Delete(QAbstractEventDispatcher* self, bool isSubclass) {
if (isSubclass) { if (isSubclass) {
delete dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( self ); delete dynamic_cast<QAbstractEventDispatcher*>( self );
} else { } else {
delete self; delete self;
} }

414
qt6/gen_qabstracteventdispatcher.go
View File

@ -53,28 +53,6 @@ func UnsafeNewQAbstractEventDispatcher(h unsafe.Pointer, h_QObject unsafe.Pointe
QObject: UnsafeNewQObject(h_QObject)} QObject: UnsafeNewQObject(h_QObject)}
} }
// NewQAbstractEventDispatcher constructs a new QAbstractEventDispatcher object.
func NewQAbstractEventDispatcher() *QAbstractEventDispatcher {
var outptr_QAbstractEventDispatcher *C.QAbstractEventDispatcher = nil
var outptr_QObject *C.QObject = nil
C.QAbstractEventDispatcher_new(&outptr_QAbstractEventDispatcher, &outptr_QObject)
ret := newQAbstractEventDispatcher(outptr_QAbstractEventDispatcher, outptr_QObject)
ret.isSubclass = true
return ret
}
// NewQAbstractEventDispatcher2 constructs a new QAbstractEventDispatcher object.
func NewQAbstractEventDispatcher2(parent *QObject) *QAbstractEventDispatcher {
var outptr_QAbstractEventDispatcher *C.QAbstractEventDispatcher = nil
var outptr_QObject *C.QObject = nil
C.QAbstractEventDispatcher_new2(parent.cPointer(), &outptr_QAbstractEventDispatcher, &outptr_QObject)
ret := newQAbstractEventDispatcher(outptr_QAbstractEventDispatcher, outptr_QObject)
ret.isSubclass = true
return ret
}
func (this *QAbstractEventDispatcher) MetaObject() *QMetaObject { func (this *QAbstractEventDispatcher) MetaObject() *QMetaObject {
return UnsafeNewQMetaObject(unsafe.Pointer(C.QAbstractEventDispatcher_MetaObject(this.h))) return UnsafeNewQMetaObject(unsafe.Pointer(C.QAbstractEventDispatcher_MetaObject(this.h)))
} }
@ -233,398 +211,6 @@ func QAbstractEventDispatcher_Tr3(s string, c string, n int) string {
func QAbstractEventDispatcher_Instance1(thread *QThread) *QAbstractEventDispatcher { func QAbstractEventDispatcher_Instance1(thread *QThread) *QAbstractEventDispatcher {
return UnsafeNewQAbstractEventDispatcher(unsafe.Pointer(C.QAbstractEventDispatcher_Instance1(thread.cPointer())), nil) return UnsafeNewQAbstractEventDispatcher(unsafe.Pointer(C.QAbstractEventDispatcher_Instance1(thread.cPointer())), nil)
} }
func (this *QAbstractEventDispatcher) OnProcessEvents(slot func(flags QEventLoop__ProcessEventsFlag) bool) {
C.QAbstractEventDispatcher_override_virtual_ProcessEvents(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_ProcessEvents
func miqt_exec_callback_QAbstractEventDispatcher_ProcessEvents(self *C.QAbstractEventDispatcher, cb C.intptr_t, flags C.int) C.bool {
gofunc, ok := cgo.Handle(cb).Value().(func(flags QEventLoop__ProcessEventsFlag) bool)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := (QEventLoop__ProcessEventsFlag)(flags)
virtualReturn := gofunc(slotval1)
return (C.bool)(virtualReturn)
}
func (this *QAbstractEventDispatcher) OnRegisterSocketNotifier(slot func(notifier *QSocketNotifier)) {
C.QAbstractEventDispatcher_override_virtual_RegisterSocketNotifier(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_RegisterSocketNotifier
func miqt_exec_callback_QAbstractEventDispatcher_RegisterSocketNotifier(self *C.QAbstractEventDispatcher, cb C.intptr_t, notifier *C.QSocketNotifier) {
gofunc, ok := cgo.Handle(cb).Value().(func(notifier *QSocketNotifier))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQSocketNotifier(unsafe.Pointer(notifier), nil)
gofunc(slotval1)
}
func (this *QAbstractEventDispatcher) OnUnregisterSocketNotifier(slot func(notifier *QSocketNotifier)) {
C.QAbstractEventDispatcher_override_virtual_UnregisterSocketNotifier(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_UnregisterSocketNotifier
func miqt_exec_callback_QAbstractEventDispatcher_UnregisterSocketNotifier(self *C.QAbstractEventDispatcher, cb C.intptr_t, notifier *C.QSocketNotifier) {
gofunc, ok := cgo.Handle(cb).Value().(func(notifier *QSocketNotifier))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQSocketNotifier(unsafe.Pointer(notifier), nil)
gofunc(slotval1)
}
func (this *QAbstractEventDispatcher) OnRegisterTimer2(slot func(timerId int, interval int64, timerType TimerType, object *QObject)) {
C.QAbstractEventDispatcher_override_virtual_RegisterTimer2(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_RegisterTimer2
func miqt_exec_callback_QAbstractEventDispatcher_RegisterTimer2(self *C.QAbstractEventDispatcher, cb C.intptr_t, timerId C.int, interval C.longlong, timerType C.int, object *C.QObject) {
gofunc, ok := cgo.Handle(cb).Value().(func(timerId int, interval int64, timerType TimerType, object *QObject))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := (int)(timerId)
slotval2 := (int64)(interval)
slotval3 := (TimerType)(timerType)
slotval4 := UnsafeNewQObject(unsafe.Pointer(object))
gofunc(slotval1, slotval2, slotval3, slotval4)
}
func (this *QAbstractEventDispatcher) OnUnregisterTimer(slot func(timerId int) bool) {
C.QAbstractEventDispatcher_override_virtual_UnregisterTimer(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimer
func miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimer(self *C.QAbstractEventDispatcher, cb C.intptr_t, timerId C.int) C.bool {
gofunc, ok := cgo.Handle(cb).Value().(func(timerId int) bool)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := (int)(timerId)
virtualReturn := gofunc(slotval1)
return (C.bool)(virtualReturn)
}
func (this *QAbstractEventDispatcher) OnUnregisterTimers(slot func(object *QObject) bool) {
C.QAbstractEventDispatcher_override_virtual_UnregisterTimers(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimers
func miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimers(self *C.QAbstractEventDispatcher, cb C.intptr_t, object *C.QObject) C.bool {
gofunc, ok := cgo.Handle(cb).Value().(func(object *QObject) bool)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQObject(unsafe.Pointer(object))
virtualReturn := gofunc(slotval1)
return (C.bool)(virtualReturn)
}
func (this *QAbstractEventDispatcher) OnRegisteredTimers(slot func(object *QObject) []QAbstractEventDispatcher__TimerInfo) {
C.QAbstractEventDispatcher_override_virtual_RegisteredTimers(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_RegisteredTimers
func miqt_exec_callback_QAbstractEventDispatcher_RegisteredTimers(self *C.QAbstractEventDispatcher, cb C.intptr_t, object *C.QObject) C.struct_miqt_array {
gofunc, ok := cgo.Handle(cb).Value().(func(object *QObject) []QAbstractEventDispatcher__TimerInfo)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQObject(unsafe.Pointer(object))
virtualReturn := gofunc(slotval1)
virtualReturn_CArray := (*[0xffff]*C.QAbstractEventDispatcher__TimerInfo)(C.malloc(C.size_t(8 * len(virtualReturn))))
defer C.free(unsafe.Pointer(virtualReturn_CArray))
for i := range virtualReturn {
virtualReturn_CArray[i] = virtualReturn[i].cPointer()
}
virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)}
return virtualReturn_ma
}
func (this *QAbstractEventDispatcher) OnRemainingTime(slot func(timerId int) int) {
C.QAbstractEventDispatcher_override_virtual_RemainingTime(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_RemainingTime
func miqt_exec_callback_QAbstractEventDispatcher_RemainingTime(self *C.QAbstractEventDispatcher, cb C.intptr_t, timerId C.int) C.int {
gofunc, ok := cgo.Handle(cb).Value().(func(timerId int) int)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := (int)(timerId)
virtualReturn := gofunc(slotval1)
return (C.int)(virtualReturn)
}
func (this *QAbstractEventDispatcher) OnWakeUp(slot func()) {
C.QAbstractEventDispatcher_override_virtual_WakeUp(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_WakeUp
func miqt_exec_callback_QAbstractEventDispatcher_WakeUp(self *C.QAbstractEventDispatcher, 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 *QAbstractEventDispatcher) OnInterrupt(slot func()) {
C.QAbstractEventDispatcher_override_virtual_Interrupt(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_Interrupt
func miqt_exec_callback_QAbstractEventDispatcher_Interrupt(self *C.QAbstractEventDispatcher, 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 *QAbstractEventDispatcher) callVirtualBase_StartingUp() {
C.QAbstractEventDispatcher_virtualbase_StartingUp(unsafe.Pointer(this.h))
}
func (this *QAbstractEventDispatcher) OnStartingUp(slot func(super func())) {
C.QAbstractEventDispatcher_override_virtual_StartingUp(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_StartingUp
func miqt_exec_callback_QAbstractEventDispatcher_StartingUp(self *C.QAbstractEventDispatcher, cb C.intptr_t) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func()))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_StartingUp)
}
func (this *QAbstractEventDispatcher) callVirtualBase_ClosingDown() {
C.QAbstractEventDispatcher_virtualbase_ClosingDown(unsafe.Pointer(this.h))
}
func (this *QAbstractEventDispatcher) OnClosingDown(slot func(super func())) {
C.QAbstractEventDispatcher_override_virtual_ClosingDown(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_ClosingDown
func miqt_exec_callback_QAbstractEventDispatcher_ClosingDown(self *C.QAbstractEventDispatcher, cb C.intptr_t) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func()))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_ClosingDown)
}
func (this *QAbstractEventDispatcher) callVirtualBase_Event(event *QEvent) bool {
return (bool)(C.QAbstractEventDispatcher_virtualbase_Event(unsafe.Pointer(this.h), event.cPointer()))
}
func (this *QAbstractEventDispatcher) OnEvent(slot func(super func(event *QEvent) bool, event *QEvent) bool) {
C.QAbstractEventDispatcher_override_virtual_Event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_Event
func miqt_exec_callback_QAbstractEventDispatcher_Event(self *C.QAbstractEventDispatcher, cb C.intptr_t, event *C.QEvent) C.bool {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent) bool, event *QEvent) bool)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQEvent(unsafe.Pointer(event))
virtualReturn := gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_Event, slotval1)
return (C.bool)(virtualReturn)
}
func (this *QAbstractEventDispatcher) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool {
return (bool)(C.QAbstractEventDispatcher_virtualbase_EventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer()))
}
func (this *QAbstractEventDispatcher) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) {
C.QAbstractEventDispatcher_override_virtual_EventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_EventFilter
func miqt_exec_callback_QAbstractEventDispatcher_EventFilter(self *C.QAbstractEventDispatcher, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQObject(unsafe.Pointer(watched))
slotval2 := UnsafeNewQEvent(unsafe.Pointer(event))
virtualReturn := gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
return (C.bool)(virtualReturn)
}
func (this *QAbstractEventDispatcher) callVirtualBase_TimerEvent(event *QTimerEvent) {
C.QAbstractEventDispatcher_virtualbase_TimerEvent(unsafe.Pointer(this.h), event.cPointer())
}
func (this *QAbstractEventDispatcher) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) {
C.QAbstractEventDispatcher_override_virtual_TimerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_TimerEvent
func miqt_exec_callback_QAbstractEventDispatcher_TimerEvent(self *C.QAbstractEventDispatcher, cb C.intptr_t, event *C.QTimerEvent) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QTimerEvent), event *QTimerEvent))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQTimerEvent(unsafe.Pointer(event), nil)
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_TimerEvent, slotval1)
}
func (this *QAbstractEventDispatcher) callVirtualBase_ChildEvent(event *QChildEvent) {
C.QAbstractEventDispatcher_virtualbase_ChildEvent(unsafe.Pointer(this.h), event.cPointer())
}
func (this *QAbstractEventDispatcher) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) {
C.QAbstractEventDispatcher_override_virtual_ChildEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_ChildEvent
func miqt_exec_callback_QAbstractEventDispatcher_ChildEvent(self *C.QAbstractEventDispatcher, cb C.intptr_t, event *C.QChildEvent) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QChildEvent), event *QChildEvent))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQChildEvent(unsafe.Pointer(event), nil)
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_ChildEvent, slotval1)
}
func (this *QAbstractEventDispatcher) callVirtualBase_CustomEvent(event *QEvent) {
C.QAbstractEventDispatcher_virtualbase_CustomEvent(unsafe.Pointer(this.h), event.cPointer())
}
func (this *QAbstractEventDispatcher) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) {
C.QAbstractEventDispatcher_override_virtual_CustomEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_CustomEvent
func miqt_exec_callback_QAbstractEventDispatcher_CustomEvent(self *C.QAbstractEventDispatcher, cb C.intptr_t, event *C.QEvent) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent), event *QEvent))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQEvent(unsafe.Pointer(event))
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_CustomEvent, slotval1)
}
func (this *QAbstractEventDispatcher) callVirtualBase_ConnectNotify(signal *QMetaMethod) {
C.QAbstractEventDispatcher_virtualbase_ConnectNotify(unsafe.Pointer(this.h), signal.cPointer())
}
func (this *QAbstractEventDispatcher) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
C.QAbstractEventDispatcher_override_virtual_ConnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_ConnectNotify
func miqt_exec_callback_QAbstractEventDispatcher_ConnectNotify(self *C.QAbstractEventDispatcher, cb C.intptr_t, signal *C.QMetaMethod) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *QMetaMethod), signal *QMetaMethod))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQMetaMethod(unsafe.Pointer(signal))
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_ConnectNotify, slotval1)
}
func (this *QAbstractEventDispatcher) callVirtualBase_DisconnectNotify(signal *QMetaMethod) {
C.QAbstractEventDispatcher_virtualbase_DisconnectNotify(unsafe.Pointer(this.h), signal.cPointer())
}
func (this *QAbstractEventDispatcher) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
C.QAbstractEventDispatcher_override_virtual_DisconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QAbstractEventDispatcher_DisconnectNotify
func miqt_exec_callback_QAbstractEventDispatcher_DisconnectNotify(self *C.QAbstractEventDispatcher, cb C.intptr_t, signal *C.QMetaMethod) {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *QMetaMethod), signal *QMetaMethod))
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := UnsafeNewQMetaMethod(unsafe.Pointer(signal))
gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_DisconnectNotify, slotval1)
}
// Delete this object from C++ memory. // Delete this object from C++ memory.
func (this *QAbstractEventDispatcher) Delete() { func (this *QAbstractEventDispatcher) Delete() {

48
qt6/gen_qabstracteventdispatcher.h
View File

@ -23,31 +23,21 @@ class QAbstractEventDispatcher__TimerInfo;
#endif #endif
class QAbstractNativeEventFilter; class QAbstractNativeEventFilter;
class QByteArray; class QByteArray;
class QChildEvent;
class QEvent;
class QMetaMethod;
class QMetaObject; class QMetaObject;
class QObject; class QObject;
class QSocketNotifier; class QSocketNotifier;
class QThread; class QThread;
class QTimerEvent;
#else #else
typedef struct QAbstractEventDispatcher QAbstractEventDispatcher; typedef struct QAbstractEventDispatcher QAbstractEventDispatcher;
typedef struct QAbstractEventDispatcher__TimerInfo QAbstractEventDispatcher__TimerInfo; typedef struct QAbstractEventDispatcher__TimerInfo QAbstractEventDispatcher__TimerInfo;
typedef struct QAbstractNativeEventFilter QAbstractNativeEventFilter; typedef struct QAbstractNativeEventFilter QAbstractNativeEventFilter;
typedef struct QByteArray QByteArray; typedef struct QByteArray QByteArray;
typedef struct QChildEvent QChildEvent;
typedef struct QEvent QEvent;
typedef struct QMetaMethod QMetaMethod;
typedef struct QMetaObject QMetaObject; typedef struct QMetaObject QMetaObject;
typedef struct QObject QObject; typedef struct QObject QObject;
typedef struct QSocketNotifier QSocketNotifier; typedef struct QSocketNotifier QSocketNotifier;
typedef struct QThread QThread; typedef struct QThread QThread;
typedef struct QTimerEvent QTimerEvent;
#endif #endif
void QAbstractEventDispatcher_new(QAbstractEventDispatcher** outptr_QAbstractEventDispatcher, QObject** outptr_QObject);
void QAbstractEventDispatcher_new2(QObject* parent, QAbstractEventDispatcher** outptr_QAbstractEventDispatcher, QObject** outptr_QObject);
QMetaObject* QAbstractEventDispatcher_MetaObject(const QAbstractEventDispatcher* self); QMetaObject* QAbstractEventDispatcher_MetaObject(const QAbstractEventDispatcher* self);
void* QAbstractEventDispatcher_Metacast(QAbstractEventDispatcher* self, const char* param1); void* QAbstractEventDispatcher_Metacast(QAbstractEventDispatcher* self, const char* param1);
struct miqt_string QAbstractEventDispatcher_Tr(const char* s); struct miqt_string QAbstractEventDispatcher_Tr(const char* s);
@ -75,44 +65,6 @@ void QAbstractEventDispatcher_connect_Awake(QAbstractEventDispatcher* self, intp
struct miqt_string QAbstractEventDispatcher_Tr2(const char* s, const char* c); struct miqt_string QAbstractEventDispatcher_Tr2(const char* s, const char* c);
struct miqt_string QAbstractEventDispatcher_Tr3(const char* s, const char* c, int n); struct miqt_string QAbstractEventDispatcher_Tr3(const char* s, const char* c, int n);
QAbstractEventDispatcher* QAbstractEventDispatcher_Instance1(QThread* thread); QAbstractEventDispatcher* QAbstractEventDispatcher_Instance1(QThread* thread);
void QAbstractEventDispatcher_override_virtual_ProcessEvents(void* self, intptr_t slot);
bool QAbstractEventDispatcher_virtualbase_ProcessEvents(void* self, int flags);
void QAbstractEventDispatcher_override_virtual_RegisterSocketNotifier(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_RegisterSocketNotifier(void* self, QSocketNotifier* notifier);
void QAbstractEventDispatcher_override_virtual_UnregisterSocketNotifier(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_UnregisterSocketNotifier(void* self, QSocketNotifier* notifier);
void QAbstractEventDispatcher_override_virtual_RegisterTimer2(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_RegisterTimer2(void* self, int timerId, long long interval, int timerType, QObject* object);
void QAbstractEventDispatcher_override_virtual_UnregisterTimer(void* self, intptr_t slot);
bool QAbstractEventDispatcher_virtualbase_UnregisterTimer(void* self, int timerId);
void QAbstractEventDispatcher_override_virtual_UnregisterTimers(void* self, intptr_t slot);
bool QAbstractEventDispatcher_virtualbase_UnregisterTimers(void* self, QObject* object);
void QAbstractEventDispatcher_override_virtual_RegisteredTimers(void* self, intptr_t slot);
struct miqt_array /* of QAbstractEventDispatcher__TimerInfo* */ QAbstractEventDispatcher_virtualbase_RegisteredTimers(const void* self, QObject* object);
void QAbstractEventDispatcher_override_virtual_RemainingTime(void* self, intptr_t slot);
int QAbstractEventDispatcher_virtualbase_RemainingTime(void* self, int timerId);
void QAbstractEventDispatcher_override_virtual_WakeUp(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_WakeUp(void* self);
void QAbstractEventDispatcher_override_virtual_Interrupt(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_Interrupt(void* self);
void QAbstractEventDispatcher_override_virtual_StartingUp(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_StartingUp(void* self);
void QAbstractEventDispatcher_override_virtual_ClosingDown(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_ClosingDown(void* self);
void QAbstractEventDispatcher_override_virtual_Event(void* self, intptr_t slot);
bool QAbstractEventDispatcher_virtualbase_Event(void* self, QEvent* event);
void QAbstractEventDispatcher_override_virtual_EventFilter(void* self, intptr_t slot);
bool QAbstractEventDispatcher_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event);
void QAbstractEventDispatcher_override_virtual_TimerEvent(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_TimerEvent(void* self, QTimerEvent* event);
void QAbstractEventDispatcher_override_virtual_ChildEvent(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_ChildEvent(void* self, QChildEvent* event);
void QAbstractEventDispatcher_override_virtual_CustomEvent(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_CustomEvent(void* self, QEvent* event);
void QAbstractEventDispatcher_override_virtual_ConnectNotify(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_ConnectNotify(void* self, QMetaMethod* signal);
void QAbstractEventDispatcher_override_virtual_DisconnectNotify(void* self, intptr_t slot);
void QAbstractEventDispatcher_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal);
void QAbstractEventDispatcher_Delete(QAbstractEventDispatcher* self, bool isSubclass); void QAbstractEventDispatcher_Delete(QAbstractEventDispatcher* self, bool isSubclass);
void QAbstractEventDispatcher__TimerInfo_new(int id, int i, int t, QAbstractEventDispatcher__TimerInfo** outptr_QAbstractEventDispatcher__TimerInfo); void QAbstractEventDispatcher__TimerInfo_new(int id, int i, int t, QAbstractEventDispatcher__TimerInfo** outptr_QAbstractEventDispatcher__TimerInfo);