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 (hide private classes, fix qintptr pointers)

Browse Source
This commit is contained in:
mappu 2024-11-19 20:01:02 +13:00
parent 392a92434a
commit 3902c9d36b
118 changed files with 699 additions and 5861 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
qt/gen_qarraydata.cpp
View File

@ -1,5 +1,4 @@
#include <QArrayData>
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QContainerImplHelper
#include <qarraydata.h>
#include "gen_qarraydata.h"
#include "_cgo_export.h"
@ -62,11 +61,3 @@ void QArrayData_Delete(QArrayData* self, bool isSubclass) {
}
}
void QtPrivate__QContainerImplHelper_Delete(QtPrivate__QContainerImplHelper* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QContainerImplHelper*>( self );
} else {
delete self;
}
}

50
qt/gen_qarraydata.go
View File

@ -129,53 +129,3 @@ func (this *QArrayData) GoGC() {
runtime.KeepAlive(this.h)
})
}
type QtPrivate__QContainerImplHelper struct {
h *C.QtPrivate__QContainerImplHelper
isSubclass bool
}
func (this *QtPrivate__QContainerImplHelper) cPointer() *C.QtPrivate__QContainerImplHelper {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QContainerImplHelper) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QContainerImplHelper constructs the type using only CGO pointers.
func newQtPrivate__QContainerImplHelper(h *C.QtPrivate__QContainerImplHelper) *QtPrivate__QContainerImplHelper {
if h == nil {
return nil
}
return &QtPrivate__QContainerImplHelper{h: h}
}
// UnsafeNewQtPrivate__QContainerImplHelper constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QContainerImplHelper(h unsafe.Pointer) *QtPrivate__QContainerImplHelper {
if h == nil {
return nil
}
return &QtPrivate__QContainerImplHelper{h: (*C.QtPrivate__QContainerImplHelper)(h)}
}
// Delete this object from C++ memory.
func (this *QtPrivate__QContainerImplHelper) Delete() {
C.QtPrivate__QContainerImplHelper_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QContainerImplHelper) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QContainerImplHelper) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

8
qt/gen_qarraydata.h
View File

@ -16,14 +16,8 @@ extern "C" {
#ifdef __cplusplus
class QArrayData;
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QContainerImplHelper)
typedef QtPrivate::QContainerImplHelper QtPrivate__QContainerImplHelper;
#else
class QtPrivate__QContainerImplHelper;
#endif
#else
typedef struct QArrayData QArrayData;
typedef struct QtPrivate__QContainerImplHelper QtPrivate__QContainerImplHelper;
#endif
void* QArrayData_Data(QArrayData* self);
@ -40,8 +34,6 @@ QArrayData* QArrayData_Allocate4(size_t objectSize, size_t alignment, size_t cap
QArrayData* QArrayData_ReallocateUnaligned4(QArrayData* data, size_t objectSize, size_t newCapacity, int newOptions);
void QArrayData_Delete(QArrayData* self, bool isSubclass);
void QtPrivate__QContainerImplHelper_Delete(QtPrivate__QContainerImplHelper* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif

14
qt/gen_qdatastream.cpp
View File

@ -1,7 +1,6 @@
#include <QByteArray>
#include <QDataStream>
#include <QIODevice>
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__StreamStateSaver
#include <qdatastream.h>
#include "gen_qdatastream.h"
#include "_cgo_export.h"
@ -219,16 +218,3 @@ void QDataStream_Delete(QDataStream* self, bool isSubclass) {
}
}
void QtPrivate__StreamStateSaver_new(QDataStream* s, QtPrivate__StreamStateSaver** outptr_QtPrivate__StreamStateSaver) {
QtPrivate::StreamStateSaver* ret = new QtPrivate::StreamStateSaver(s);
*outptr_QtPrivate__StreamStateSaver = ret;
}
void QtPrivate__StreamStateSaver_Delete(QtPrivate__StreamStateSaver* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::StreamStateSaver*>( self );
} else {
delete self;
}
}

60
qt/gen_qdatastream.go
View File

@ -352,63 +352,3 @@ func (this *QDataStream) GoGC() {
runtime.KeepAlive(this.h)
})
}
type QtPrivate__StreamStateSaver struct {
h *C.QtPrivate__StreamStateSaver
isSubclass bool
}
func (this *QtPrivate__StreamStateSaver) cPointer() *C.QtPrivate__StreamStateSaver {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__StreamStateSaver) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__StreamStateSaver constructs the type using only CGO pointers.
func newQtPrivate__StreamStateSaver(h *C.QtPrivate__StreamStateSaver) *QtPrivate__StreamStateSaver {
if h == nil {
return nil
}
return &QtPrivate__StreamStateSaver{h: h}
}
// UnsafeNewQtPrivate__StreamStateSaver constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__StreamStateSaver(h unsafe.Pointer) *QtPrivate__StreamStateSaver {
if h == nil {
return nil
}
return &QtPrivate__StreamStateSaver{h: (*C.QtPrivate__StreamStateSaver)(h)}
}
// NewQtPrivate__StreamStateSaver constructs a new QtPrivate::StreamStateSaver object.
func NewQtPrivate__StreamStateSaver(s *QDataStream) *QtPrivate__StreamStateSaver {
var outptr_QtPrivate__StreamStateSaver *C.QtPrivate__StreamStateSaver = nil
C.QtPrivate__StreamStateSaver_new(s.cPointer(), &outptr_QtPrivate__StreamStateSaver)
ret := newQtPrivate__StreamStateSaver(outptr_QtPrivate__StreamStateSaver)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtPrivate__StreamStateSaver) Delete() {
C.QtPrivate__StreamStateSaver_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__StreamStateSaver) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__StreamStateSaver) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

9
qt/gen_qdatastream.h
View File

@ -18,16 +18,10 @@ extern "C" {
class QByteArray;
class QDataStream;
class QIODevice;
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__StreamStateSaver)
typedef QtPrivate::StreamStateSaver QtPrivate__StreamStateSaver;
#else
class QtPrivate__StreamStateSaver;
#endif
#else
typedef struct QByteArray QByteArray;
typedef struct QDataStream QDataStream;
typedef struct QIODevice QIODevice;
typedef struct QtPrivate__StreamStateSaver QtPrivate__StreamStateSaver;
#endif
void QDataStream_new(QDataStream** outptr_QDataStream);
@ -81,9 +75,6 @@ void QDataStream_RollbackTransaction(QDataStream* self);
void QDataStream_AbortTransaction(QDataStream* self);
void QDataStream_Delete(QDataStream* self, bool isSubclass);
void QtPrivate__StreamStateSaver_new(QDataStream* s, QtPrivate__StreamStateSaver** outptr_QtPrivate__StreamStateSaver);
void QtPrivate__StreamStateSaver_Delete(QtPrivate__StreamStateSaver* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif

39
qt/gen_qexception.cpp
View File

@ -1,39 +0,0 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ExceptionHolder
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ExceptionStore
#include <qexception.h>
#include "gen_qexception.h"
#include "_cgo_export.h"
void QtPrivate__ExceptionHolder_new(QtPrivate__ExceptionHolder** outptr_QtPrivate__ExceptionHolder) {
QtPrivate::ExceptionHolder* ret = new QtPrivate::ExceptionHolder();
*outptr_QtPrivate__ExceptionHolder = ret;
}
void QtPrivate__ExceptionHolder_Delete(QtPrivate__ExceptionHolder* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::ExceptionHolder*>( self );
} else {
delete self;
}
}
bool QtPrivate__ExceptionStore_HasException(const QtPrivate__ExceptionStore* self) {
return self->hasException();
}
void QtPrivate__ExceptionStore_ThrowPossibleException(QtPrivate__ExceptionStore* self) {
self->throwPossibleException();
}
bool QtPrivate__ExceptionStore_HasThrown(const QtPrivate__ExceptionStore* self) {
return self->hasThrown();
}
void QtPrivate__ExceptionStore_Delete(QtPrivate__ExceptionStore* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::ExceptionStore*>( self );
} else {
delete self;
}
}

136
qt/gen_qexception.go
View File

@ -1,136 +0,0 @@
package qt
/*
#include "gen_qexception.h"
#include <stdlib.h>
*/
import "C"
import (
"runtime"
"unsafe"
)
type QtPrivate__ExceptionHolder struct {
h *C.QtPrivate__ExceptionHolder
isSubclass bool
}
func (this *QtPrivate__ExceptionHolder) cPointer() *C.QtPrivate__ExceptionHolder {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__ExceptionHolder) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__ExceptionHolder constructs the type using only CGO pointers.
func newQtPrivate__ExceptionHolder(h *C.QtPrivate__ExceptionHolder) *QtPrivate__ExceptionHolder {
if h == nil {
return nil
}
return &QtPrivate__ExceptionHolder{h: h}
}
// UnsafeNewQtPrivate__ExceptionHolder constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__ExceptionHolder(h unsafe.Pointer) *QtPrivate__ExceptionHolder {
if h == nil {
return nil
}
return &QtPrivate__ExceptionHolder{h: (*C.QtPrivate__ExceptionHolder)(h)}
}
// NewQtPrivate__ExceptionHolder constructs a new QtPrivate::ExceptionHolder object.
func NewQtPrivate__ExceptionHolder() *QtPrivate__ExceptionHolder {
var outptr_QtPrivate__ExceptionHolder *C.QtPrivate__ExceptionHolder = nil
C.QtPrivate__ExceptionHolder_new(&outptr_QtPrivate__ExceptionHolder)
ret := newQtPrivate__ExceptionHolder(outptr_QtPrivate__ExceptionHolder)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtPrivate__ExceptionHolder) Delete() {
C.QtPrivate__ExceptionHolder_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__ExceptionHolder) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__ExceptionHolder) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__ExceptionStore struct {
h *C.QtPrivate__ExceptionStore
isSubclass bool
}
func (this *QtPrivate__ExceptionStore) cPointer() *C.QtPrivate__ExceptionStore {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__ExceptionStore) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__ExceptionStore constructs the type using only CGO pointers.
func newQtPrivate__ExceptionStore(h *C.QtPrivate__ExceptionStore) *QtPrivate__ExceptionStore {
if h == nil {
return nil
}
return &QtPrivate__ExceptionStore{h: h}
}
// UnsafeNewQtPrivate__ExceptionStore constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__ExceptionStore(h unsafe.Pointer) *QtPrivate__ExceptionStore {
if h == nil {
return nil
}
return &QtPrivate__ExceptionStore{h: (*C.QtPrivate__ExceptionStore)(h)}
}
func (this *QtPrivate__ExceptionStore) HasException() bool {
return (bool)(C.QtPrivate__ExceptionStore_HasException(this.h))
}
func (this *QtPrivate__ExceptionStore) ThrowPossibleException() {
C.QtPrivate__ExceptionStore_ThrowPossibleException(this.h)
}
func (this *QtPrivate__ExceptionStore) HasThrown() bool {
return (bool)(C.QtPrivate__ExceptionStore_HasThrown(this.h))
}
// Delete this object from C++ memory.
func (this *QtPrivate__ExceptionStore) Delete() {
C.QtPrivate__ExceptionStore_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__ExceptionStore) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__ExceptionStore) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

45
qt/gen_qexception.h
View File

@ -1,45 +0,0 @@
#pragma once
#ifndef MIQT_QT_GEN_QEXCEPTION_H
#define MIQT_QT_GEN_QEXCEPTION_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ExceptionHolder)
typedef QtPrivate::ExceptionHolder QtPrivate__ExceptionHolder;
#else
class QtPrivate__ExceptionHolder;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ExceptionStore)
typedef QtPrivate::ExceptionStore QtPrivate__ExceptionStore;
#else
class QtPrivate__ExceptionStore;
#endif
#else
typedef struct QtPrivate__ExceptionHolder QtPrivate__ExceptionHolder;
typedef struct QtPrivate__ExceptionStore QtPrivate__ExceptionStore;
#endif
void QtPrivate__ExceptionHolder_new(QtPrivate__ExceptionHolder** outptr_QtPrivate__ExceptionHolder);
void QtPrivate__ExceptionHolder_Delete(QtPrivate__ExceptionHolder* self, bool isSubclass);
bool QtPrivate__ExceptionStore_HasException(const QtPrivate__ExceptionStore* self);
void QtPrivate__ExceptionStore_ThrowPossibleException(QtPrivate__ExceptionStore* self);
bool QtPrivate__ExceptionStore_HasThrown(const QtPrivate__ExceptionStore* self);
void QtPrivate__ExceptionStore_Delete(QtPrivate__ExceptionStore* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

32
qt/gen_qhashfunctions.cpp
View File

@ -1,32 +0,0 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QHashCombine
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QHashCombineCommutative
#include <qhashfunctions.h>
#include "gen_qhashfunctions.h"
#include "_cgo_export.h"
void QtPrivate__QHashCombine_new(QtPrivate__QHashCombine** outptr_QtPrivate__QHashCombine) {
QtPrivate::QHashCombine* ret = new QtPrivate::QHashCombine();
*outptr_QtPrivate__QHashCombine = ret;
}
void QtPrivate__QHashCombine_Delete(QtPrivate__QHashCombine* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QHashCombine*>( self );
} else {
delete self;
}
}
void QtPrivate__QHashCombineCommutative_new(QtPrivate__QHashCombineCommutative** outptr_QtPrivate__QHashCombineCommutative) {
QtPrivate::QHashCombineCommutative* ret = new QtPrivate::QHashCombineCommutative();
*outptr_QtPrivate__QHashCombineCommutative = ret;
}
void QtPrivate__QHashCombineCommutative_Delete(QtPrivate__QHashCombineCommutative* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QHashCombineCommutative*>( self );
} else {
delete self;
}
}

134
qt/gen_qhashfunctions.go
View File

@ -1,134 +0,0 @@
package qt
/*
#include "gen_qhashfunctions.h"
#include <stdlib.h>
*/
import "C"
import (
"runtime"
"unsafe"
)
type QtPrivate__QHashCombine struct {
h *C.QtPrivate__QHashCombine
isSubclass bool
}
func (this *QtPrivate__QHashCombine) cPointer() *C.QtPrivate__QHashCombine {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QHashCombine) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QHashCombine constructs the type using only CGO pointers.
func newQtPrivate__QHashCombine(h *C.QtPrivate__QHashCombine) *QtPrivate__QHashCombine {
if h == nil {
return nil
}
return &QtPrivate__QHashCombine{h: h}
}
// UnsafeNewQtPrivate__QHashCombine constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QHashCombine(h unsafe.Pointer) *QtPrivate__QHashCombine {
if h == nil {
return nil
}
return &QtPrivate__QHashCombine{h: (*C.QtPrivate__QHashCombine)(h)}
}
// NewQtPrivate__QHashCombine constructs a new QtPrivate::QHashCombine object.
func NewQtPrivate__QHashCombine() *QtPrivate__QHashCombine {
var outptr_QtPrivate__QHashCombine *C.QtPrivate__QHashCombine = nil
C.QtPrivate__QHashCombine_new(&outptr_QtPrivate__QHashCombine)
ret := newQtPrivate__QHashCombine(outptr_QtPrivate__QHashCombine)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtPrivate__QHashCombine) Delete() {
C.QtPrivate__QHashCombine_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QHashCombine) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QHashCombine) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__QHashCombineCommutative struct {
h *C.QtPrivate__QHashCombineCommutative
isSubclass bool
}
func (this *QtPrivate__QHashCombineCommutative) cPointer() *C.QtPrivate__QHashCombineCommutative {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QHashCombineCommutative) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QHashCombineCommutative constructs the type using only CGO pointers.
func newQtPrivate__QHashCombineCommutative(h *C.QtPrivate__QHashCombineCommutative) *QtPrivate__QHashCombineCommutative {
if h == nil {
return nil
}
return &QtPrivate__QHashCombineCommutative{h: h}
}
// UnsafeNewQtPrivate__QHashCombineCommutative constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QHashCombineCommutative(h unsafe.Pointer) *QtPrivate__QHashCombineCommutative {
if h == nil {
return nil
}
return &QtPrivate__QHashCombineCommutative{h: (*C.QtPrivate__QHashCombineCommutative)(h)}
}
// NewQtPrivate__QHashCombineCommutative constructs a new QtPrivate::QHashCombineCommutative object.
func NewQtPrivate__QHashCombineCommutative() *QtPrivate__QHashCombineCommutative {
var outptr_QtPrivate__QHashCombineCommutative *C.QtPrivate__QHashCombineCommutative = nil
C.QtPrivate__QHashCombineCommutative_new(&outptr_QtPrivate__QHashCombineCommutative)
ret := newQtPrivate__QHashCombineCommutative(outptr_QtPrivate__QHashCombineCommutative)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtPrivate__QHashCombineCommutative) Delete() {
C.QtPrivate__QHashCombineCommutative_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QHashCombineCommutative) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QHashCombineCommutative) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

43
qt/gen_qhashfunctions.h
View File

@ -1,43 +0,0 @@
#pragma once
#ifndef MIQT_QT_GEN_QHASHFUNCTIONS_H
#define MIQT_QT_GEN_QHASHFUNCTIONS_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QHashCombine)
typedef QtPrivate::QHashCombine QtPrivate__QHashCombine;
#else
class QtPrivate__QHashCombine;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QHashCombineCommutative)
typedef QtPrivate::QHashCombineCommutative QtPrivate__QHashCombineCommutative;
#else
class QtPrivate__QHashCombineCommutative;
#endif
#else
typedef struct QtPrivate__QHashCombine QtPrivate__QHashCombine;
typedef struct QtPrivate__QHashCombineCommutative QtPrivate__QHashCombineCommutative;
#endif
void QtPrivate__QHashCombine_new(QtPrivate__QHashCombine** outptr_QtPrivate__QHashCombine);
void QtPrivate__QHashCombine_Delete(QtPrivate__QHashCombine* self, bool isSubclass);
void QtPrivate__QHashCombineCommutative_new(QtPrivate__QHashCombineCommutative** outptr_QtPrivate__QHashCombineCommutative);
void QtPrivate__QHashCombineCommutative_Delete(QtPrivate__QHashCombineCommutative* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

242
qt/gen_qmetatype.cpp
View File

@ -3,57 +3,10 @@
#include <QDebug>
#include <QMetaObject>
#include <QMetaType>
#define WORKAROUND_INNER_CLASS_DEFINITION_QtMetaTypePrivate__QAssociativeIterableImpl
#define WORKAROUND_INNER_CLASS_DEFINITION_QtMetaTypePrivate__QPairVariantInterfaceImpl
#define WORKAROUND_INNER_CLASS_DEFINITION_QtMetaTypePrivate__QSequentialIterableImpl
#define WORKAROUND_INNER_CLASS_DEFINITION_QtMetaTypePrivate__VariantData
#define WORKAROUND_INNER_CLASS_DEFINITION_QtMetaTypePrivate__VectorBoolElements
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__AbstractComparatorFunction
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__AbstractConverterFunction
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__AbstractDebugStreamFunction
#include <qmetatype.h>
#include "gen_qmetatype.h"
#include "_cgo_export.h"
void QtPrivate__AbstractDebugStreamFunction_new(QtPrivate__AbstractDebugStreamFunction** outptr_QtPrivate__AbstractDebugStreamFunction) {
QtPrivate::AbstractDebugStreamFunction* ret = new QtPrivate::AbstractDebugStreamFunction();
*outptr_QtPrivate__AbstractDebugStreamFunction = ret;
}
void QtPrivate__AbstractDebugStreamFunction_Delete(QtPrivate__AbstractDebugStreamFunction* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::AbstractDebugStreamFunction*>( self );
} else {
delete self;
}
}
void QtPrivate__AbstractComparatorFunction_new(QtPrivate__AbstractComparatorFunction** outptr_QtPrivate__AbstractComparatorFunction) {
QtPrivate::AbstractComparatorFunction* ret = new QtPrivate::AbstractComparatorFunction();
*outptr_QtPrivate__AbstractComparatorFunction = ret;
}
void QtPrivate__AbstractComparatorFunction_Delete(QtPrivate__AbstractComparatorFunction* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::AbstractComparatorFunction*>( self );
} else {
delete self;
}
}
void QtPrivate__AbstractConverterFunction_new(QtPrivate__AbstractConverterFunction** outptr_QtPrivate__AbstractConverterFunction) {
QtPrivate::AbstractConverterFunction* ret = new QtPrivate::AbstractConverterFunction();
*outptr_QtPrivate__AbstractConverterFunction = ret;
}
void QtPrivate__AbstractConverterFunction_Delete(QtPrivate__AbstractConverterFunction* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::AbstractConverterFunction*>( self );
} else {
delete self;
}
}
void QMetaType_new(QMetaType** outptr_QMetaType) {
QMetaType* ret = new QMetaType();
*outptr_QMetaType = ret;
@ -229,198 +182,3 @@ void QMetaType_Delete(QMetaType* self, bool isSubclass) {
}
}
void QtMetaTypePrivate__VariantData_new(const int metaTypeId_, const void* data_, const unsigned int flags_, QtMetaTypePrivate__VariantData** outptr_QtMetaTypePrivate__VariantData) {
QtMetaTypePrivate::VariantData* ret = new QtMetaTypePrivate::VariantData(static_cast<const int>(metaTypeId_), data_, static_cast<const uint>(flags_));
*outptr_QtMetaTypePrivate__VariantData = ret;
}
void QtMetaTypePrivate__VariantData_new2(QtMetaTypePrivate__VariantData* other, QtMetaTypePrivate__VariantData** outptr_QtMetaTypePrivate__VariantData) {
QtMetaTypePrivate::VariantData* ret = new QtMetaTypePrivate::VariantData(*other);
*outptr_QtMetaTypePrivate__VariantData = ret;
}
void QtMetaTypePrivate__VariantData_Delete(QtMetaTypePrivate__VariantData* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtMetaTypePrivate::VariantData*>( self );
} else {
delete self;
}
}
void QtMetaTypePrivate__VectorBoolElements_Delete(QtMetaTypePrivate__VectorBoolElements* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtMetaTypePrivate::VectorBoolElements*>( self );
} else {
delete self;
}
}
void QtMetaTypePrivate__QSequentialIterableImpl_new(QtMetaTypePrivate__QSequentialIterableImpl** outptr_QtMetaTypePrivate__QSequentialIterableImpl) {
QtMetaTypePrivate::QSequentialIterableImpl* ret = new QtMetaTypePrivate::QSequentialIterableImpl();
*outptr_QtMetaTypePrivate__QSequentialIterableImpl = ret;
}
void QtMetaTypePrivate__QSequentialIterableImpl_new2(QtMetaTypePrivate__QSequentialIterableImpl* param1, QtMetaTypePrivate__QSequentialIterableImpl** outptr_QtMetaTypePrivate__QSequentialIterableImpl) {
QtMetaTypePrivate::QSequentialIterableImpl* ret = new QtMetaTypePrivate::QSequentialIterableImpl(*param1);
*outptr_QtMetaTypePrivate__QSequentialIterableImpl = ret;
}
int QtMetaTypePrivate__QSequentialIterableImpl_IteratorCapabilities(QtMetaTypePrivate__QSequentialIterableImpl* self) {
QtMetaTypePrivate::IteratorCapability _ret = self->iteratorCapabilities();
return static_cast<int>(_ret);
}
unsigned int QtMetaTypePrivate__QSequentialIterableImpl_Revision(QtMetaTypePrivate__QSequentialIterableImpl* self) {
uint _ret = self->revision();
return static_cast<unsigned int>(_ret);
}
unsigned int QtMetaTypePrivate__QSequentialIterableImpl_ContainerCapabilities(QtMetaTypePrivate__QSequentialIterableImpl* self) {
uint _ret = self->containerCapabilities();
return static_cast<unsigned int>(_ret);
}
void QtMetaTypePrivate__QSequentialIterableImpl_MoveToBegin(QtMetaTypePrivate__QSequentialIterableImpl* self) {
self->moveToBegin();
}
void QtMetaTypePrivate__QSequentialIterableImpl_MoveToEnd(QtMetaTypePrivate__QSequentialIterableImpl* self) {
self->moveToEnd();
}
bool QtMetaTypePrivate__QSequentialIterableImpl_Equal(const QtMetaTypePrivate__QSequentialIterableImpl* self, QtMetaTypePrivate__QSequentialIterableImpl* other) {
return self->equal(*other);
}
QtMetaTypePrivate__QSequentialIterableImpl* QtMetaTypePrivate__QSequentialIterableImpl_Advance(QtMetaTypePrivate__QSequentialIterableImpl* self, int i) {
QtMetaTypePrivate::QSequentialIterableImpl& _ret = self->advance(static_cast<int>(i));
// Cast returned reference into pointer
return &_ret;
}
void QtMetaTypePrivate__QSequentialIterableImpl_Append(QtMetaTypePrivate__QSequentialIterableImpl* self, const void* newElement) {
self->append(newElement);
}
QtMetaTypePrivate__VariantData* QtMetaTypePrivate__QSequentialIterableImpl_GetCurrent(const QtMetaTypePrivate__QSequentialIterableImpl* self) {
return new QtMetaTypePrivate::VariantData(self->getCurrent());
}
QtMetaTypePrivate__VariantData* QtMetaTypePrivate__QSequentialIterableImpl_At(const QtMetaTypePrivate__QSequentialIterableImpl* self, int idx) {
return new QtMetaTypePrivate::VariantData(self->at(static_cast<int>(idx)));
}
int QtMetaTypePrivate__QSequentialIterableImpl_Size(const QtMetaTypePrivate__QSequentialIterableImpl* self) {
return self->size();
}
void QtMetaTypePrivate__QSequentialIterableImpl_DestroyIter(QtMetaTypePrivate__QSequentialIterableImpl* self) {
self->destroyIter();
}
void QtMetaTypePrivate__QSequentialIterableImpl_Copy(QtMetaTypePrivate__QSequentialIterableImpl* self, QtMetaTypePrivate__QSequentialIterableImpl* other) {
self->copy(*other);
}
void QtMetaTypePrivate__QSequentialIterableImpl_OperatorAssign(QtMetaTypePrivate__QSequentialIterableImpl* self, QtMetaTypePrivate__QSequentialIterableImpl* param1) {
self->operator=(*param1);
}
void QtMetaTypePrivate__QSequentialIterableImpl_Delete(QtMetaTypePrivate__QSequentialIterableImpl* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtMetaTypePrivate::QSequentialIterableImpl*>( self );
} else {
delete self;
}
}
void QtMetaTypePrivate__QAssociativeIterableImpl_new(QtMetaTypePrivate__QAssociativeIterableImpl** outptr_QtMetaTypePrivate__QAssociativeIterableImpl) {
QtMetaTypePrivate::QAssociativeIterableImpl* ret = new QtMetaTypePrivate::QAssociativeIterableImpl();
*outptr_QtMetaTypePrivate__QAssociativeIterableImpl = ret;
}
void QtMetaTypePrivate__QAssociativeIterableImpl_new2(QtMetaTypePrivate__QAssociativeIterableImpl* param1, QtMetaTypePrivate__QAssociativeIterableImpl** outptr_QtMetaTypePrivate__QAssociativeIterableImpl) {
QtMetaTypePrivate::QAssociativeIterableImpl* ret = new QtMetaTypePrivate::QAssociativeIterableImpl(*param1);
*outptr_QtMetaTypePrivate__QAssociativeIterableImpl = ret;
}
void QtMetaTypePrivate__QAssociativeIterableImpl_Begin(QtMetaTypePrivate__QAssociativeIterableImpl* self) {
self->begin();
}
void QtMetaTypePrivate__QAssociativeIterableImpl_End(QtMetaTypePrivate__QAssociativeIterableImpl* self) {
self->end();
}
bool QtMetaTypePrivate__QAssociativeIterableImpl_Equal(const QtMetaTypePrivate__QAssociativeIterableImpl* self, QtMetaTypePrivate__QAssociativeIterableImpl* other) {
return self->equal(*other);
}
QtMetaTypePrivate__QAssociativeIterableImpl* QtMetaTypePrivate__QAssociativeIterableImpl_Advance(QtMetaTypePrivate__QAssociativeIterableImpl* self, int i) {
QtMetaTypePrivate::QAssociativeIterableImpl& _ret = self->advance(static_cast<int>(i));
// Cast returned reference into pointer
return &_ret;
}
void QtMetaTypePrivate__QAssociativeIterableImpl_DestroyIter(QtMetaTypePrivate__QAssociativeIterableImpl* self) {
self->destroyIter();
}
QtMetaTypePrivate__VariantData* QtMetaTypePrivate__QAssociativeIterableImpl_GetCurrentKey(const QtMetaTypePrivate__QAssociativeIterableImpl* self) {
return new QtMetaTypePrivate::VariantData(self->getCurrentKey());
}
QtMetaTypePrivate__VariantData* QtMetaTypePrivate__QAssociativeIterableImpl_GetCurrentValue(const QtMetaTypePrivate__QAssociativeIterableImpl* self) {
return new QtMetaTypePrivate::VariantData(self->getCurrentValue());
}
void QtMetaTypePrivate__QAssociativeIterableImpl_Find(QtMetaTypePrivate__QAssociativeIterableImpl* self, QtMetaTypePrivate__VariantData* key) {
self->find(*key);
}
int QtMetaTypePrivate__QAssociativeIterableImpl_Size(const QtMetaTypePrivate__QAssociativeIterableImpl* self) {
return self->size();
}
void QtMetaTypePrivate__QAssociativeIterableImpl_Copy(QtMetaTypePrivate__QAssociativeIterableImpl* self, QtMetaTypePrivate__QAssociativeIterableImpl* other) {
self->copy(*other);
}
void QtMetaTypePrivate__QAssociativeIterableImpl_OperatorAssign(QtMetaTypePrivate__QAssociativeIterableImpl* self, QtMetaTypePrivate__QAssociativeIterableImpl* param1) {
self->operator=(*param1);
}
void QtMetaTypePrivate__QAssociativeIterableImpl_Delete(QtMetaTypePrivate__QAssociativeIterableImpl* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtMetaTypePrivate::QAssociativeIterableImpl*>( self );
} else {
delete self;
}
}
void QtMetaTypePrivate__QPairVariantInterfaceImpl_new(QtMetaTypePrivate__QPairVariantInterfaceImpl** outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl) {
QtMetaTypePrivate::QPairVariantInterfaceImpl* ret = new QtMetaTypePrivate::QPairVariantInterfaceImpl();
*outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl = ret;
}
void QtMetaTypePrivate__QPairVariantInterfaceImpl_new2(QtMetaTypePrivate__QPairVariantInterfaceImpl* param1, QtMetaTypePrivate__QPairVariantInterfaceImpl** outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl) {
QtMetaTypePrivate::QPairVariantInterfaceImpl* ret = new QtMetaTypePrivate::QPairVariantInterfaceImpl(*param1);
*outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl = ret;
}
QtMetaTypePrivate__VariantData* QtMetaTypePrivate__QPairVariantInterfaceImpl_First(const QtMetaTypePrivate__QPairVariantInterfaceImpl* self) {
return new QtMetaTypePrivate::VariantData(self->first());
}
QtMetaTypePrivate__VariantData* QtMetaTypePrivate__QPairVariantInterfaceImpl_Second(const QtMetaTypePrivate__QPairVariantInterfaceImpl* self) {
return new QtMetaTypePrivate::VariantData(self->second());
}
void QtMetaTypePrivate__QPairVariantInterfaceImpl_Delete(QtMetaTypePrivate__QPairVariantInterfaceImpl* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtMetaTypePrivate::QPairVariantInterfaceImpl*>( self );
} else {
delete self;
}
}

636
qt/gen_qmetatype.go
View File

@ -147,186 +147,6 @@ const (
QtMetaTypePrivate__QSequentialIterableImpl__ToEnd QtMetaTypePrivate__QSequentialIterableImpl__Position = 1
)
type QtPrivate__AbstractDebugStreamFunction struct {
h *C.QtPrivate__AbstractDebugStreamFunction
isSubclass bool
}
func (this *QtPrivate__AbstractDebugStreamFunction) cPointer() *C.QtPrivate__AbstractDebugStreamFunction {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__AbstractDebugStreamFunction) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__AbstractDebugStreamFunction constructs the type using only CGO pointers.
func newQtPrivate__AbstractDebugStreamFunction(h *C.QtPrivate__AbstractDebugStreamFunction) *QtPrivate__AbstractDebugStreamFunction {
if h == nil {
return nil
}
return &QtPrivate__AbstractDebugStreamFunction{h: h}
}
// UnsafeNewQtPrivate__AbstractDebugStreamFunction constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__AbstractDebugStreamFunction(h unsafe.Pointer) *QtPrivate__AbstractDebugStreamFunction {
if h == nil {
return nil
}
return &QtPrivate__AbstractDebugStreamFunction{h: (*C.QtPrivate__AbstractDebugStreamFunction)(h)}
}
// NewQtPrivate__AbstractDebugStreamFunction constructs a new QtPrivate::AbstractDebugStreamFunction object.
func NewQtPrivate__AbstractDebugStreamFunction() *QtPrivate__AbstractDebugStreamFunction {
var outptr_QtPrivate__AbstractDebugStreamFunction *C.QtPrivate__AbstractDebugStreamFunction = nil
C.QtPrivate__AbstractDebugStreamFunction_new(&outptr_QtPrivate__AbstractDebugStreamFunction)
ret := newQtPrivate__AbstractDebugStreamFunction(outptr_QtPrivate__AbstractDebugStreamFunction)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtPrivate__AbstractDebugStreamFunction) Delete() {
C.QtPrivate__AbstractDebugStreamFunction_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__AbstractDebugStreamFunction) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__AbstractDebugStreamFunction) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__AbstractComparatorFunction struct {
h *C.QtPrivate__AbstractComparatorFunction
isSubclass bool
}
func (this *QtPrivate__AbstractComparatorFunction) cPointer() *C.QtPrivate__AbstractComparatorFunction {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__AbstractComparatorFunction) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__AbstractComparatorFunction constructs the type using only CGO pointers.
func newQtPrivate__AbstractComparatorFunction(h *C.QtPrivate__AbstractComparatorFunction) *QtPrivate__AbstractComparatorFunction {
if h == nil {
return nil
}
return &QtPrivate__AbstractComparatorFunction{h: h}
}
// UnsafeNewQtPrivate__AbstractComparatorFunction constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__AbstractComparatorFunction(h unsafe.Pointer) *QtPrivate__AbstractComparatorFunction {
if h == nil {
return nil
}
return &QtPrivate__AbstractComparatorFunction{h: (*C.QtPrivate__AbstractComparatorFunction)(h)}
}
// NewQtPrivate__AbstractComparatorFunction constructs a new QtPrivate::AbstractComparatorFunction object.
func NewQtPrivate__AbstractComparatorFunction() *QtPrivate__AbstractComparatorFunction {
var outptr_QtPrivate__AbstractComparatorFunction *C.QtPrivate__AbstractComparatorFunction = nil
C.QtPrivate__AbstractComparatorFunction_new(&outptr_QtPrivate__AbstractComparatorFunction)
ret := newQtPrivate__AbstractComparatorFunction(outptr_QtPrivate__AbstractComparatorFunction)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtPrivate__AbstractComparatorFunction) Delete() {
C.QtPrivate__AbstractComparatorFunction_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__AbstractComparatorFunction) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__AbstractComparatorFunction) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__AbstractConverterFunction struct {
h *C.QtPrivate__AbstractConverterFunction
isSubclass bool
}
func (this *QtPrivate__AbstractConverterFunction) cPointer() *C.QtPrivate__AbstractConverterFunction {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__AbstractConverterFunction) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__AbstractConverterFunction constructs the type using only CGO pointers.
func newQtPrivate__AbstractConverterFunction(h *C.QtPrivate__AbstractConverterFunction) *QtPrivate__AbstractConverterFunction {
if h == nil {
return nil
}
return &QtPrivate__AbstractConverterFunction{h: h}
}
// UnsafeNewQtPrivate__AbstractConverterFunction constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__AbstractConverterFunction(h unsafe.Pointer) *QtPrivate__AbstractConverterFunction {
if h == nil {
return nil
}
return &QtPrivate__AbstractConverterFunction{h: (*C.QtPrivate__AbstractConverterFunction)(h)}
}
// NewQtPrivate__AbstractConverterFunction constructs a new QtPrivate::AbstractConverterFunction object.
func NewQtPrivate__AbstractConverterFunction() *QtPrivate__AbstractConverterFunction {
var outptr_QtPrivate__AbstractConverterFunction *C.QtPrivate__AbstractConverterFunction = nil
C.QtPrivate__AbstractConverterFunction_new(&outptr_QtPrivate__AbstractConverterFunction)
ret := newQtPrivate__AbstractConverterFunction(outptr_QtPrivate__AbstractConverterFunction)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtPrivate__AbstractConverterFunction) Delete() {
C.QtPrivate__AbstractConverterFunction_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__AbstractConverterFunction) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__AbstractConverterFunction) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QMetaType struct {
h *C.QMetaType
isSubclass bool
@ -558,459 +378,3 @@ func (this *QMetaType) GoGC() {
runtime.KeepAlive(this.h)
})
}
type QtMetaTypePrivate__VariantData struct {
h *C.QtMetaTypePrivate__VariantData
isSubclass bool
}
func (this *QtMetaTypePrivate__VariantData) cPointer() *C.QtMetaTypePrivate__VariantData {
if this == nil {
return nil
}
return this.h
}
func (this *QtMetaTypePrivate__VariantData) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtMetaTypePrivate__VariantData constructs the type using only CGO pointers.
func newQtMetaTypePrivate__VariantData(h *C.QtMetaTypePrivate__VariantData) *QtMetaTypePrivate__VariantData {
if h == nil {
return nil
}
return &QtMetaTypePrivate__VariantData{h: h}
}
// UnsafeNewQtMetaTypePrivate__VariantData constructs the type using only unsafe pointers.
func UnsafeNewQtMetaTypePrivate__VariantData(h unsafe.Pointer) *QtMetaTypePrivate__VariantData {
if h == nil {
return nil
}
return &QtMetaTypePrivate__VariantData{h: (*C.QtMetaTypePrivate__VariantData)(h)}
}
// NewQtMetaTypePrivate__VariantData constructs a new QtMetaTypePrivate::VariantData object.
func NewQtMetaTypePrivate__VariantData(metaTypeId_ int, data_ unsafe.Pointer, flags_ uint) *QtMetaTypePrivate__VariantData {
var outptr_QtMetaTypePrivate__VariantData *C.QtMetaTypePrivate__VariantData = nil
C.QtMetaTypePrivate__VariantData_new((C.int)(metaTypeId_), data_, (C.uint)(flags_), &outptr_QtMetaTypePrivate__VariantData)
ret := newQtMetaTypePrivate__VariantData(outptr_QtMetaTypePrivate__VariantData)
ret.isSubclass = true
return ret
}
// NewQtMetaTypePrivate__VariantData2 constructs a new QtMetaTypePrivate::VariantData object.
func NewQtMetaTypePrivate__VariantData2(other *QtMetaTypePrivate__VariantData) *QtMetaTypePrivate__VariantData {
var outptr_QtMetaTypePrivate__VariantData *C.QtMetaTypePrivate__VariantData = nil
C.QtMetaTypePrivate__VariantData_new2(other.cPointer(), &outptr_QtMetaTypePrivate__VariantData)
ret := newQtMetaTypePrivate__VariantData(outptr_QtMetaTypePrivate__VariantData)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtMetaTypePrivate__VariantData) Delete() {
C.QtMetaTypePrivate__VariantData_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtMetaTypePrivate__VariantData) GoGC() {
runtime.SetFinalizer(this, func(this *QtMetaTypePrivate__VariantData) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtMetaTypePrivate__VectorBoolElements struct {
h *C.QtMetaTypePrivate__VectorBoolElements
isSubclass bool
}
func (this *QtMetaTypePrivate__VectorBoolElements) cPointer() *C.QtMetaTypePrivate__VectorBoolElements {
if this == nil {
return nil
}
return this.h
}
func (this *QtMetaTypePrivate__VectorBoolElements) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtMetaTypePrivate__VectorBoolElements constructs the type using only CGO pointers.
func newQtMetaTypePrivate__VectorBoolElements(h *C.QtMetaTypePrivate__VectorBoolElements) *QtMetaTypePrivate__VectorBoolElements {
if h == nil {
return nil
}
return &QtMetaTypePrivate__VectorBoolElements{h: h}
}
// UnsafeNewQtMetaTypePrivate__VectorBoolElements constructs the type using only unsafe pointers.
func UnsafeNewQtMetaTypePrivate__VectorBoolElements(h unsafe.Pointer) *QtMetaTypePrivate__VectorBoolElements {
if h == nil {
return nil
}
return &QtMetaTypePrivate__VectorBoolElements{h: (*C.QtMetaTypePrivate__VectorBoolElements)(h)}
}
// Delete this object from C++ memory.
func (this *QtMetaTypePrivate__VectorBoolElements) Delete() {
C.QtMetaTypePrivate__VectorBoolElements_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtMetaTypePrivate__VectorBoolElements) GoGC() {
runtime.SetFinalizer(this, func(this *QtMetaTypePrivate__VectorBoolElements) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtMetaTypePrivate__QSequentialIterableImpl struct {
h *C.QtMetaTypePrivate__QSequentialIterableImpl
isSubclass bool
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) cPointer() *C.QtMetaTypePrivate__QSequentialIterableImpl {
if this == nil {
return nil
}
return this.h
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtMetaTypePrivate__QSequentialIterableImpl constructs the type using only CGO pointers.
func newQtMetaTypePrivate__QSequentialIterableImpl(h *C.QtMetaTypePrivate__QSequentialIterableImpl) *QtMetaTypePrivate__QSequentialIterableImpl {
if h == nil {
return nil
}
return &QtMetaTypePrivate__QSequentialIterableImpl{h: h}
}
// UnsafeNewQtMetaTypePrivate__QSequentialIterableImpl constructs the type using only unsafe pointers.
func UnsafeNewQtMetaTypePrivate__QSequentialIterableImpl(h unsafe.Pointer) *QtMetaTypePrivate__QSequentialIterableImpl {
if h == nil {
return nil
}
return &QtMetaTypePrivate__QSequentialIterableImpl{h: (*C.QtMetaTypePrivate__QSequentialIterableImpl)(h)}
}
// NewQtMetaTypePrivate__QSequentialIterableImpl constructs a new QtMetaTypePrivate::QSequentialIterableImpl object.
func NewQtMetaTypePrivate__QSequentialIterableImpl() *QtMetaTypePrivate__QSequentialIterableImpl {
var outptr_QtMetaTypePrivate__QSequentialIterableImpl *C.QtMetaTypePrivate__QSequentialIterableImpl = nil
C.QtMetaTypePrivate__QSequentialIterableImpl_new(&outptr_QtMetaTypePrivate__QSequentialIterableImpl)
ret := newQtMetaTypePrivate__QSequentialIterableImpl(outptr_QtMetaTypePrivate__QSequentialIterableImpl)
ret.isSubclass = true
return ret
}
// NewQtMetaTypePrivate__QSequentialIterableImpl2 constructs a new QtMetaTypePrivate::QSequentialIterableImpl object.
func NewQtMetaTypePrivate__QSequentialIterableImpl2(param1 *QtMetaTypePrivate__QSequentialIterableImpl) *QtMetaTypePrivate__QSequentialIterableImpl {
var outptr_QtMetaTypePrivate__QSequentialIterableImpl *C.QtMetaTypePrivate__QSequentialIterableImpl = nil
C.QtMetaTypePrivate__QSequentialIterableImpl_new2(param1.cPointer(), &outptr_QtMetaTypePrivate__QSequentialIterableImpl)
ret := newQtMetaTypePrivate__QSequentialIterableImpl(outptr_QtMetaTypePrivate__QSequentialIterableImpl)
ret.isSubclass = true
return ret
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) IteratorCapabilities() QtMetaTypePrivate__IteratorCapability {
return (QtMetaTypePrivate__IteratorCapability)(C.QtMetaTypePrivate__QSequentialIterableImpl_IteratorCapabilities(this.h))
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) Revision() uint {
return (uint)(C.QtMetaTypePrivate__QSequentialIterableImpl_Revision(this.h))
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) ContainerCapabilities() uint {
return (uint)(C.QtMetaTypePrivate__QSequentialIterableImpl_ContainerCapabilities(this.h))
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) MoveToBegin() {
C.QtMetaTypePrivate__QSequentialIterableImpl_MoveToBegin(this.h)
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) MoveToEnd() {
C.QtMetaTypePrivate__QSequentialIterableImpl_MoveToEnd(this.h)
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) Equal(other *QtMetaTypePrivate__QSequentialIterableImpl) bool {
return (bool)(C.QtMetaTypePrivate__QSequentialIterableImpl_Equal(this.h, other.cPointer()))
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) Advance(i int) *QtMetaTypePrivate__QSequentialIterableImpl {
return UnsafeNewQtMetaTypePrivate__QSequentialIterableImpl(unsafe.Pointer(C.QtMetaTypePrivate__QSequentialIterableImpl_Advance(this.h, (C.int)(i))))
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) Append(newElement unsafe.Pointer) {
C.QtMetaTypePrivate__QSequentialIterableImpl_Append(this.h, newElement)
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) GetCurrent() *QtMetaTypePrivate__VariantData {
_ret := C.QtMetaTypePrivate__QSequentialIterableImpl_GetCurrent(this.h)
_goptr := newQtMetaTypePrivate__VariantData(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) At(idx int) *QtMetaTypePrivate__VariantData {
_ret := C.QtMetaTypePrivate__QSequentialIterableImpl_At(this.h, (C.int)(idx))
_goptr := newQtMetaTypePrivate__VariantData(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) Size() int {
return (int)(C.QtMetaTypePrivate__QSequentialIterableImpl_Size(this.h))
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) DestroyIter() {
C.QtMetaTypePrivate__QSequentialIterableImpl_DestroyIter(this.h)
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) Copy(other *QtMetaTypePrivate__QSequentialIterableImpl) {
C.QtMetaTypePrivate__QSequentialIterableImpl_Copy(this.h, other.cPointer())
}
func (this *QtMetaTypePrivate__QSequentialIterableImpl) OperatorAssign(param1 *QtMetaTypePrivate__QSequentialIterableImpl) {
C.QtMetaTypePrivate__QSequentialIterableImpl_OperatorAssign(this.h, param1.cPointer())
}
// Delete this object from C++ memory.
func (this *QtMetaTypePrivate__QSequentialIterableImpl) Delete() {
C.QtMetaTypePrivate__QSequentialIterableImpl_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtMetaTypePrivate__QSequentialIterableImpl) GoGC() {
runtime.SetFinalizer(this, func(this *QtMetaTypePrivate__QSequentialIterableImpl) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtMetaTypePrivate__QAssociativeIterableImpl struct {
h *C.QtMetaTypePrivate__QAssociativeIterableImpl
isSubclass bool
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) cPointer() *C.QtMetaTypePrivate__QAssociativeIterableImpl {
if this == nil {
return nil
}
return this.h
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtMetaTypePrivate__QAssociativeIterableImpl constructs the type using only CGO pointers.
func newQtMetaTypePrivate__QAssociativeIterableImpl(h *C.QtMetaTypePrivate__QAssociativeIterableImpl) *QtMetaTypePrivate__QAssociativeIterableImpl {
if h == nil {
return nil
}
return &QtMetaTypePrivate__QAssociativeIterableImpl{h: h}
}
// UnsafeNewQtMetaTypePrivate__QAssociativeIterableImpl constructs the type using only unsafe pointers.
func UnsafeNewQtMetaTypePrivate__QAssociativeIterableImpl(h unsafe.Pointer) *QtMetaTypePrivate__QAssociativeIterableImpl {
if h == nil {
return nil
}
return &QtMetaTypePrivate__QAssociativeIterableImpl{h: (*C.QtMetaTypePrivate__QAssociativeIterableImpl)(h)}
}
// NewQtMetaTypePrivate__QAssociativeIterableImpl constructs a new QtMetaTypePrivate::QAssociativeIterableImpl object.
func NewQtMetaTypePrivate__QAssociativeIterableImpl() *QtMetaTypePrivate__QAssociativeIterableImpl {
var outptr_QtMetaTypePrivate__QAssociativeIterableImpl *C.QtMetaTypePrivate__QAssociativeIterableImpl = nil
C.QtMetaTypePrivate__QAssociativeIterableImpl_new(&outptr_QtMetaTypePrivate__QAssociativeIterableImpl)
ret := newQtMetaTypePrivate__QAssociativeIterableImpl(outptr_QtMetaTypePrivate__QAssociativeIterableImpl)
ret.isSubclass = true
return ret
}
// NewQtMetaTypePrivate__QAssociativeIterableImpl2 constructs a new QtMetaTypePrivate::QAssociativeIterableImpl object.
func NewQtMetaTypePrivate__QAssociativeIterableImpl2(param1 *QtMetaTypePrivate__QAssociativeIterableImpl) *QtMetaTypePrivate__QAssociativeIterableImpl {
var outptr_QtMetaTypePrivate__QAssociativeIterableImpl *C.QtMetaTypePrivate__QAssociativeIterableImpl = nil
C.QtMetaTypePrivate__QAssociativeIterableImpl_new2(param1.cPointer(), &outptr_QtMetaTypePrivate__QAssociativeIterableImpl)
ret := newQtMetaTypePrivate__QAssociativeIterableImpl(outptr_QtMetaTypePrivate__QAssociativeIterableImpl)
ret.isSubclass = true
return ret
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) Begin() {
C.QtMetaTypePrivate__QAssociativeIterableImpl_Begin(this.h)
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) End() {
C.QtMetaTypePrivate__QAssociativeIterableImpl_End(this.h)
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) Equal(other *QtMetaTypePrivate__QAssociativeIterableImpl) bool {
return (bool)(C.QtMetaTypePrivate__QAssociativeIterableImpl_Equal(this.h, other.cPointer()))
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) Advance(i int) *QtMetaTypePrivate__QAssociativeIterableImpl {
return UnsafeNewQtMetaTypePrivate__QAssociativeIterableImpl(unsafe.Pointer(C.QtMetaTypePrivate__QAssociativeIterableImpl_Advance(this.h, (C.int)(i))))
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) DestroyIter() {
C.QtMetaTypePrivate__QAssociativeIterableImpl_DestroyIter(this.h)
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) GetCurrentKey() *QtMetaTypePrivate__VariantData {
_ret := C.QtMetaTypePrivate__QAssociativeIterableImpl_GetCurrentKey(this.h)
_goptr := newQtMetaTypePrivate__VariantData(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) GetCurrentValue() *QtMetaTypePrivate__VariantData {
_ret := C.QtMetaTypePrivate__QAssociativeIterableImpl_GetCurrentValue(this.h)
_goptr := newQtMetaTypePrivate__VariantData(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) Find(key *QtMetaTypePrivate__VariantData) {
C.QtMetaTypePrivate__QAssociativeIterableImpl_Find(this.h, key.cPointer())
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) Size() int {
return (int)(C.QtMetaTypePrivate__QAssociativeIterableImpl_Size(this.h))
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) Copy(other *QtMetaTypePrivate__QAssociativeIterableImpl) {
C.QtMetaTypePrivate__QAssociativeIterableImpl_Copy(this.h, other.cPointer())
}
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) OperatorAssign(param1 *QtMetaTypePrivate__QAssociativeIterableImpl) {
C.QtMetaTypePrivate__QAssociativeIterableImpl_OperatorAssign(this.h, param1.cPointer())
}
// Delete this object from C++ memory.
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) Delete() {
C.QtMetaTypePrivate__QAssociativeIterableImpl_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtMetaTypePrivate__QAssociativeIterableImpl) GoGC() {
runtime.SetFinalizer(this, func(this *QtMetaTypePrivate__QAssociativeIterableImpl) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtMetaTypePrivate__QPairVariantInterfaceImpl struct {
h *C.QtMetaTypePrivate__QPairVariantInterfaceImpl
isSubclass bool
}
func (this *QtMetaTypePrivate__QPairVariantInterfaceImpl) cPointer() *C.QtMetaTypePrivate__QPairVariantInterfaceImpl {
if this == nil {
return nil
}
return this.h
}
func (this *QtMetaTypePrivate__QPairVariantInterfaceImpl) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtMetaTypePrivate__QPairVariantInterfaceImpl constructs the type using only CGO pointers.
func newQtMetaTypePrivate__QPairVariantInterfaceImpl(h *C.QtMetaTypePrivate__QPairVariantInterfaceImpl) *QtMetaTypePrivate__QPairVariantInterfaceImpl {
if h == nil {
return nil
}
return &QtMetaTypePrivate__QPairVariantInterfaceImpl{h: h}
}
// UnsafeNewQtMetaTypePrivate__QPairVariantInterfaceImpl constructs the type using only unsafe pointers.
func UnsafeNewQtMetaTypePrivate__QPairVariantInterfaceImpl(h unsafe.Pointer) *QtMetaTypePrivate__QPairVariantInterfaceImpl {
if h == nil {
return nil
}
return &QtMetaTypePrivate__QPairVariantInterfaceImpl{h: (*C.QtMetaTypePrivate__QPairVariantInterfaceImpl)(h)}
}
// NewQtMetaTypePrivate__QPairVariantInterfaceImpl constructs a new QtMetaTypePrivate::QPairVariantInterfaceImpl object.
func NewQtMetaTypePrivate__QPairVariantInterfaceImpl() *QtMetaTypePrivate__QPairVariantInterfaceImpl {
var outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl *C.QtMetaTypePrivate__QPairVariantInterfaceImpl = nil
C.QtMetaTypePrivate__QPairVariantInterfaceImpl_new(&outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl)
ret := newQtMetaTypePrivate__QPairVariantInterfaceImpl(outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl)
ret.isSubclass = true
return ret
}
// NewQtMetaTypePrivate__QPairVariantInterfaceImpl2 constructs a new QtMetaTypePrivate::QPairVariantInterfaceImpl object.
func NewQtMetaTypePrivate__QPairVariantInterfaceImpl2(param1 *QtMetaTypePrivate__QPairVariantInterfaceImpl) *QtMetaTypePrivate__QPairVariantInterfaceImpl {
var outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl *C.QtMetaTypePrivate__QPairVariantInterfaceImpl = nil
C.QtMetaTypePrivate__QPairVariantInterfaceImpl_new2(param1.cPointer(), &outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl)
ret := newQtMetaTypePrivate__QPairVariantInterfaceImpl(outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl)
ret.isSubclass = true
return ret
}
func (this *QtMetaTypePrivate__QPairVariantInterfaceImpl) First() *QtMetaTypePrivate__VariantData {
_ret := C.QtMetaTypePrivate__QPairVariantInterfaceImpl_First(this.h)
_goptr := newQtMetaTypePrivate__VariantData(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QtMetaTypePrivate__QPairVariantInterfaceImpl) Second() *QtMetaTypePrivate__VariantData {
_ret := C.QtMetaTypePrivate__QPairVariantInterfaceImpl_Second(this.h)
_goptr := newQtMetaTypePrivate__VariantData(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
// Delete this object from C++ memory.
func (this *QtMetaTypePrivate__QPairVariantInterfaceImpl) Delete() {
C.QtMetaTypePrivate__QPairVariantInterfaceImpl_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtMetaTypePrivate__QPairVariantInterfaceImpl) GoGC() {
runtime.SetFinalizer(this, func(this *QtMetaTypePrivate__QPairVariantInterfaceImpl) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

102
qt/gen_qmetatype.h
View File

@ -20,71 +20,14 @@ class QDataStream;
class QDebug;
class QMetaObject;
class QMetaType;
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtMetaTypePrivate__QAssociativeIterableImpl)
typedef QtMetaTypePrivate::QAssociativeIterableImpl QtMetaTypePrivate__QAssociativeIterableImpl;
#else
class QtMetaTypePrivate__QAssociativeIterableImpl;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtMetaTypePrivate__QPairVariantInterfaceImpl)
typedef QtMetaTypePrivate::QPairVariantInterfaceImpl QtMetaTypePrivate__QPairVariantInterfaceImpl;
#else
class QtMetaTypePrivate__QPairVariantInterfaceImpl;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtMetaTypePrivate__QSequentialIterableImpl)
typedef QtMetaTypePrivate::QSequentialIterableImpl QtMetaTypePrivate__QSequentialIterableImpl;
#else
class QtMetaTypePrivate__QSequentialIterableImpl;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtMetaTypePrivate__VariantData)
typedef QtMetaTypePrivate::VariantData QtMetaTypePrivate__VariantData;
#else
class QtMetaTypePrivate__VariantData;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtMetaTypePrivate__VectorBoolElements)
typedef QtMetaTypePrivate::VectorBoolElements QtMetaTypePrivate__VectorBoolElements;
#else
class QtMetaTypePrivate__VectorBoolElements;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__AbstractComparatorFunction)
typedef QtPrivate::AbstractComparatorFunction QtPrivate__AbstractComparatorFunction;
#else
class QtPrivate__AbstractComparatorFunction;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__AbstractConverterFunction)
typedef QtPrivate::AbstractConverterFunction QtPrivate__AbstractConverterFunction;
#else
class QtPrivate__AbstractConverterFunction;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__AbstractDebugStreamFunction)
typedef QtPrivate::AbstractDebugStreamFunction QtPrivate__AbstractDebugStreamFunction;
#else
class QtPrivate__AbstractDebugStreamFunction;
#endif
#else
typedef struct QByteArray QByteArray;
typedef struct QDataStream QDataStream;
typedef struct QDebug QDebug;
typedef struct QMetaObject QMetaObject;
typedef struct QMetaType QMetaType;
typedef struct QtMetaTypePrivate__QAssociativeIterableImpl QtMetaTypePrivate__QAssociativeIterableImpl;
typedef struct QtMetaTypePrivate__QPairVariantInterfaceImpl QtMetaTypePrivate__QPairVariantInterfaceImpl;
typedef struct QtMetaTypePrivate__QSequentialIterableImpl QtMetaTypePrivate__QSequentialIterableImpl;
typedef struct QtMetaTypePrivate__VariantData QtMetaTypePrivate__VariantData;
typedef struct QtMetaTypePrivate__VectorBoolElements QtMetaTypePrivate__VectorBoolElements;
typedef struct QtPrivate__AbstractComparatorFunction QtPrivate__AbstractComparatorFunction;
typedef struct QtPrivate__AbstractConverterFunction QtPrivate__AbstractConverterFunction;
typedef struct QtPrivate__AbstractDebugStreamFunction QtPrivate__AbstractDebugStreamFunction;
#endif
void QtPrivate__AbstractDebugStreamFunction_new(QtPrivate__AbstractDebugStreamFunction** outptr_QtPrivate__AbstractDebugStreamFunction);
void QtPrivate__AbstractDebugStreamFunction_Delete(QtPrivate__AbstractDebugStreamFunction* self, bool isSubclass);
void QtPrivate__AbstractComparatorFunction_new(QtPrivate__AbstractComparatorFunction** outptr_QtPrivate__AbstractComparatorFunction);
void QtPrivate__AbstractComparatorFunction_Delete(QtPrivate__AbstractComparatorFunction* self, bool isSubclass);
void QtPrivate__AbstractConverterFunction_new(QtPrivate__AbstractConverterFunction** outptr_QtPrivate__AbstractConverterFunction);
void QtPrivate__AbstractConverterFunction_Delete(QtPrivate__AbstractConverterFunction* self, bool isSubclass);
void QMetaType_new(QMetaType** outptr_QMetaType);
void QMetaType_new2(const int typeVal, QMetaType** outptr_QMetaType);
bool QMetaType_UnregisterType(int typeVal);
@ -126,51 +69,6 @@ void* QMetaType_Create1(const QMetaType* self, const void* copyVal);
void* QMetaType_Construct2(const QMetaType* self, void* where, const void* copyVal);
void QMetaType_Delete(QMetaType* self, bool isSubclass);
void QtMetaTypePrivate__VariantData_new(const int metaTypeId_, const void* data_, const unsigned int flags_, QtMetaTypePrivate__VariantData** outptr_QtMetaTypePrivate__VariantData);
void QtMetaTypePrivate__VariantData_new2(QtMetaTypePrivate__VariantData* other, QtMetaTypePrivate__VariantData** outptr_QtMetaTypePrivate__VariantData);
void QtMetaTypePrivate__VariantData_Delete(QtMetaTypePrivate__VariantData* self, bool isSubclass);
void QtMetaTypePrivate__VectorBoolElements_Delete(QtMetaTypePrivate__VectorBoolElements* self, bool isSubclass);
void QtMetaTypePrivate__QSequentialIterableImpl_new(QtMetaTypePrivate__QSequentialIterableImpl** outptr_QtMetaTypePrivate__QSequentialIterableImpl);
void QtMetaTypePrivate__QSequentialIterableImpl_new2(QtMetaTypePrivate__QSequentialIterableImpl* param1, QtMetaTypePrivate__QSequentialIterableImpl** outptr_QtMetaTypePrivate__QSequentialIterableImpl);
int QtMetaTypePrivate__QSequentialIterableImpl_IteratorCapabilities(QtMetaTypePrivate__QSequentialIterableImpl* self);
unsigned int QtMetaTypePrivate__QSequentialIterableImpl_Revision(QtMetaTypePrivate__QSequentialIterableImpl* self);
unsigned int QtMetaTypePrivate__QSequentialIterableImpl_ContainerCapabilities(QtMetaTypePrivate__QSequentialIterableImpl* self);
void QtMetaTypePrivate__QSequentialIterableImpl_MoveToBegin(QtMetaTypePrivate__QSequentialIterableImpl* self);
void QtMetaTypePrivate__QSequentialIterableImpl_MoveToEnd(QtMetaTypePrivate__QSequentialIterableImpl* self);
bool QtMetaTypePrivate__QSequentialIterableImpl_Equal(const QtMetaTypePrivate__QSequentialIterableImpl* self, QtMetaTypePrivate__QSequentialIterableImpl* other);
QtMetaTypePrivate__QSequentialIterableImpl* QtMetaTypePrivate__QSequentialIterableImpl_Advance(QtMetaTypePrivate__QSequentialIterableImpl* self, int i);
void QtMetaTypePrivate__QSequentialIterableImpl_Append(QtMetaTypePrivate__QSequentialIterableImpl* self, const void* newElement);
QtMetaTypePrivate__VariantData* QtMetaTypePrivate__QSequentialIterableImpl_GetCurrent(const QtMetaTypePrivate__QSequentialIterableImpl* self);
QtMetaTypePrivate__VariantData* QtMetaTypePrivate__QSequentialIterableImpl_At(const QtMetaTypePrivate__QSequentialIterableImpl* self, int idx);
int QtMetaTypePrivate__QSequentialIterableImpl_Size(const QtMetaTypePrivate__QSequentialIterableImpl* self);
void QtMetaTypePrivate__QSequentialIterableImpl_DestroyIter(QtMetaTypePrivate__QSequentialIterableImpl* self);
void QtMetaTypePrivate__QSequentialIterableImpl_Copy(QtMetaTypePrivate__QSequentialIterableImpl* self, QtMetaTypePrivate__QSequentialIterableImpl* other);
void QtMetaTypePrivate__QSequentialIterableImpl_OperatorAssign(QtMetaTypePrivate__QSequentialIterableImpl* self, QtMetaTypePrivate__QSequentialIterableImpl* param1);
void QtMetaTypePrivate__QSequentialIterableImpl_Delete(QtMetaTypePrivate__QSequentialIterableImpl* self, bool isSubclass);
void QtMetaTypePrivate__QAssociativeIterableImpl_new(QtMetaTypePrivate__QAssociativeIterableImpl** outptr_QtMetaTypePrivate__QAssociativeIterableImpl);
void QtMetaTypePrivate__QAssociativeIterableImpl_new2(QtMetaTypePrivate__QAssociativeIterableImpl* param1, QtMetaTypePrivate__QAssociativeIterableImpl** outptr_QtMetaTypePrivate__QAssociativeIterableImpl);
void QtMetaTypePrivate__QAssociativeIterableImpl_Begin(QtMetaTypePrivate__QAssociativeIterableImpl* self);
void QtMetaTypePrivate__QAssociativeIterableImpl_End(QtMetaTypePrivate__QAssociativeIterableImpl* self);
bool QtMetaTypePrivate__QAssociativeIterableImpl_Equal(const QtMetaTypePrivate__QAssociativeIterableImpl* self, QtMetaTypePrivate__QAssociativeIterableImpl* other);
QtMetaTypePrivate__QAssociativeIterableImpl* QtMetaTypePrivate__QAssociativeIterableImpl_Advance(QtMetaTypePrivate__QAssociativeIterableImpl* self, int i);
void QtMetaTypePrivate__QAssociativeIterableImpl_DestroyIter(QtMetaTypePrivate__QAssociativeIterableImpl* self);
QtMetaTypePrivate__VariantData* QtMetaTypePrivate__QAssociativeIterableImpl_GetCurrentKey(const QtMetaTypePrivate__QAssociativeIterableImpl* self);
QtMetaTypePrivate__VariantData* QtMetaTypePrivate__QAssociativeIterableImpl_GetCurrentValue(const QtMetaTypePrivate__QAssociativeIterableImpl* self);
void QtMetaTypePrivate__QAssociativeIterableImpl_Find(QtMetaTypePrivate__QAssociativeIterableImpl* self, QtMetaTypePrivate__VariantData* key);
int QtMetaTypePrivate__QAssociativeIterableImpl_Size(const QtMetaTypePrivate__QAssociativeIterableImpl* self);
void QtMetaTypePrivate__QAssociativeIterableImpl_Copy(QtMetaTypePrivate__QAssociativeIterableImpl* self, QtMetaTypePrivate__QAssociativeIterableImpl* other);
void QtMetaTypePrivate__QAssociativeIterableImpl_OperatorAssign(QtMetaTypePrivate__QAssociativeIterableImpl* self, QtMetaTypePrivate__QAssociativeIterableImpl* param1);
void QtMetaTypePrivate__QAssociativeIterableImpl_Delete(QtMetaTypePrivate__QAssociativeIterableImpl* self, bool isSubclass);
void QtMetaTypePrivate__QPairVariantInterfaceImpl_new(QtMetaTypePrivate__QPairVariantInterfaceImpl** outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl);
void QtMetaTypePrivate__QPairVariantInterfaceImpl_new2(QtMetaTypePrivate__QPairVariantInterfaceImpl* param1, QtMetaTypePrivate__QPairVariantInterfaceImpl** outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl);
QtMetaTypePrivate__VariantData* QtMetaTypePrivate__QPairVariantInterfaceImpl_First(const QtMetaTypePrivate__QPairVariantInterfaceImpl* self);
QtMetaTypePrivate__VariantData* QtMetaTypePrivate__QPairVariantInterfaceImpl_Second(const QtMetaTypePrivate__QPairVariantInterfaceImpl* self);
void QtMetaTypePrivate__QPairVariantInterfaceImpl_Delete(QtMetaTypePrivate__QPairVariantInterfaceImpl* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif

45
qt/gen_qrefcount.cpp
View File

@ -1,45 +0,0 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__RefCount
#include <qrefcount.h>
#include "gen_qrefcount.h"
#include "_cgo_export.h"
bool QtPrivate__RefCount_Ref(QtPrivate__RefCount* self) {
return self->ref();
}
bool QtPrivate__RefCount_Deref(QtPrivate__RefCount* self) {
return self->deref();
}
bool QtPrivate__RefCount_SetSharable(QtPrivate__RefCount* self, bool sharable) {
return self->setSharable(sharable);
}
bool QtPrivate__RefCount_IsSharable(const QtPrivate__RefCount* self) {
return self->isSharable();
}
bool QtPrivate__RefCount_IsStatic(const QtPrivate__RefCount* self) {
return self->isStatic();
}
bool QtPrivate__RefCount_IsShared(const QtPrivate__RefCount* self) {
return self->isShared();
}
void QtPrivate__RefCount_InitializeOwned(QtPrivate__RefCount* self) {
self->initializeOwned();
}
void QtPrivate__RefCount_InitializeUnsharable(QtPrivate__RefCount* self) {
self->initializeUnsharable();
}
void QtPrivate__RefCount_Delete(QtPrivate__RefCount* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::RefCount*>( self );
} else {
delete self;
}
}

96
qt/gen_qrefcount.go
View File

@ -1,96 +0,0 @@
package qt
/*
#include "gen_qrefcount.h"
#include <stdlib.h>
*/
import "C"
import (
"runtime"
"unsafe"
)
type QtPrivate__RefCount struct {
h *C.QtPrivate__RefCount
isSubclass bool
}
func (this *QtPrivate__RefCount) cPointer() *C.QtPrivate__RefCount {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__RefCount) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__RefCount constructs the type using only CGO pointers.
func newQtPrivate__RefCount(h *C.QtPrivate__RefCount) *QtPrivate__RefCount {
if h == nil {
return nil
}
return &QtPrivate__RefCount{h: h}
}
// UnsafeNewQtPrivate__RefCount constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__RefCount(h unsafe.Pointer) *QtPrivate__RefCount {
if h == nil {
return nil
}
return &QtPrivate__RefCount{h: (*C.QtPrivate__RefCount)(h)}
}
func (this *QtPrivate__RefCount) Ref() bool {
return (bool)(C.QtPrivate__RefCount_Ref(this.h))
}
func (this *QtPrivate__RefCount) Deref() bool {
return (bool)(C.QtPrivate__RefCount_Deref(this.h))
}
func (this *QtPrivate__RefCount) SetSharable(sharable bool) bool {
return (bool)(C.QtPrivate__RefCount_SetSharable(this.h, (C.bool)(sharable)))
}
func (this *QtPrivate__RefCount) IsSharable() bool {
return (bool)(C.QtPrivate__RefCount_IsSharable(this.h))
}
func (this *QtPrivate__RefCount) IsStatic() bool {
return (bool)(C.QtPrivate__RefCount_IsStatic(this.h))
}
func (this *QtPrivate__RefCount) IsShared() bool {
return (bool)(C.QtPrivate__RefCount_IsShared(this.h))
}
func (this *QtPrivate__RefCount) InitializeOwned() {
C.QtPrivate__RefCount_InitializeOwned(this.h)
}
func (this *QtPrivate__RefCount) InitializeUnsharable() {
C.QtPrivate__RefCount_InitializeUnsharable(this.h)
}
// Delete this object from C++ memory.
func (this *QtPrivate__RefCount) Delete() {
C.QtPrivate__RefCount_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__RefCount) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__RefCount) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

41
qt/gen_qrefcount.h
View File

@ -1,41 +0,0 @@
#pragma once
#ifndef MIQT_QT_GEN_QREFCOUNT_H
#define MIQT_QT_GEN_QREFCOUNT_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__RefCount)
typedef QtPrivate::RefCount QtPrivate__RefCount;
#else
class QtPrivate__RefCount;
#endif
#else
typedef struct QtPrivate__RefCount QtPrivate__RefCount;
#endif
bool QtPrivate__RefCount_Ref(QtPrivate__RefCount* self);
bool QtPrivate__RefCount_Deref(QtPrivate__RefCount* self);
bool QtPrivate__RefCount_SetSharable(QtPrivate__RefCount* self, bool sharable);
bool QtPrivate__RefCount_IsSharable(const QtPrivate__RefCount* self);
bool QtPrivate__RefCount_IsStatic(const QtPrivate__RefCount* self);
bool QtPrivate__RefCount_IsShared(const QtPrivate__RefCount* self);
void QtPrivate__RefCount_InitializeOwned(QtPrivate__RefCount* self);
void QtPrivate__RefCount_InitializeUnsharable(QtPrivate__RefCount* self);
void QtPrivate__RefCount_Delete(QtPrivate__RefCount* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

124
qt/gen_qresultstore.cpp
View File

@ -1,124 +0,0 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ResultItem
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ResultIteratorBase
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ResultStoreBase
#include <qresultstore.h>
#include "gen_qresultstore.h"
#include "_cgo_export.h"
void QtPrivate__ResultItem_new(const void* _result, int _count, QtPrivate__ResultItem** outptr_QtPrivate__ResultItem) {
QtPrivate::ResultItem* ret = new QtPrivate::ResultItem(_result, static_cast<int>(_count));
*outptr_QtPrivate__ResultItem = ret;
}
void QtPrivate__ResultItem_new2(const void* _result, QtPrivate__ResultItem** outptr_QtPrivate__ResultItem) {
QtPrivate::ResultItem* ret = new QtPrivate::ResultItem(_result);
*outptr_QtPrivate__ResultItem = ret;
}
void QtPrivate__ResultItem_new3(QtPrivate__ResultItem** outptr_QtPrivate__ResultItem) {
QtPrivate::ResultItem* ret = new QtPrivate::ResultItem();
*outptr_QtPrivate__ResultItem = ret;
}
bool QtPrivate__ResultItem_IsValid(const QtPrivate__ResultItem* self) {
return self->isValid();
}
bool QtPrivate__ResultItem_IsVector(const QtPrivate__ResultItem* self) {
return self->isVector();
}
int QtPrivate__ResultItem_Count(const QtPrivate__ResultItem* self) {
return self->count();
}
void QtPrivate__ResultItem_Delete(QtPrivate__ResultItem* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::ResultItem*>( self );
} else {
delete self;
}
}
void QtPrivate__ResultIteratorBase_new(QtPrivate__ResultIteratorBase** outptr_QtPrivate__ResultIteratorBase) {
QtPrivate::ResultIteratorBase* ret = new QtPrivate::ResultIteratorBase();
*outptr_QtPrivate__ResultIteratorBase = ret;
}
int QtPrivate__ResultIteratorBase_VectorIndex(const QtPrivate__ResultIteratorBase* self) {
return self->vectorIndex();
}
int QtPrivate__ResultIteratorBase_ResultIndex(const QtPrivate__ResultIteratorBase* self) {
return self->resultIndex();
}
int QtPrivate__ResultIteratorBase_BatchSize(const QtPrivate__ResultIteratorBase* self) {
return self->batchSize();
}
void QtPrivate__ResultIteratorBase_BatchedAdvance(QtPrivate__ResultIteratorBase* self) {
self->batchedAdvance();
}
bool QtPrivate__ResultIteratorBase_IsVector(const QtPrivate__ResultIteratorBase* self) {
return self->isVector();
}
bool QtPrivate__ResultIteratorBase_CanIncrementVectorIndex(const QtPrivate__ResultIteratorBase* self) {
return self->canIncrementVectorIndex();
}
void QtPrivate__ResultIteratorBase_Delete(QtPrivate__ResultIteratorBase* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::ResultIteratorBase*>( self );
} else {
delete self;
}
}
void QtPrivate__ResultStoreBase_new(QtPrivate__ResultStoreBase** outptr_QtPrivate__ResultStoreBase) {
QtPrivate::ResultStoreBase* ret = new QtPrivate::ResultStoreBase();
*outptr_QtPrivate__ResultStoreBase = ret;
}
void QtPrivate__ResultStoreBase_SetFilterMode(QtPrivate__ResultStoreBase* self, bool enable) {
self->setFilterMode(enable);
}
bool QtPrivate__ResultStoreBase_FilterMode(const QtPrivate__ResultStoreBase* self) {
return self->filterMode();
}
int QtPrivate__ResultStoreBase_AddResult(QtPrivate__ResultStoreBase* self, int index, const void* result) {
return self->addResult(static_cast<int>(index), result);
}
int QtPrivate__ResultStoreBase_AddResults(QtPrivate__ResultStoreBase* self, int index, const void* results, int vectorSize, int logicalCount) {
return self->addResults(static_cast<int>(index), results, static_cast<int>(vectorSize), static_cast<int>(logicalCount));
}
bool QtPrivate__ResultStoreBase_HasNextResult(const QtPrivate__ResultStoreBase* self) {
return self->hasNextResult();
}
bool QtPrivate__ResultStoreBase_Contains(const QtPrivate__ResultStoreBase* self, int index) {
return self->contains(static_cast<int>(index));
}
int QtPrivate__ResultStoreBase_Count(const QtPrivate__ResultStoreBase* self) {
return self->count();
}
int QtPrivate__ResultStoreBase_AddCanceledResult(QtPrivate__ResultStoreBase* self, int index) {
return self->addCanceledResult(static_cast<int>(index));
}
void QtPrivate__ResultStoreBase_Delete(QtPrivate__ResultStoreBase* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::ResultStoreBase*>( self );
} else {
delete self;
}
}

282
qt/gen_qresultstore.go
View File

@ -1,282 +0,0 @@
package qt
/*
#include "gen_qresultstore.h"
#include <stdlib.h>
*/
import "C"
import (
"runtime"
"unsafe"
)
type QtPrivate__ResultItem struct {
h *C.QtPrivate__ResultItem
isSubclass bool
}
func (this *QtPrivate__ResultItem) cPointer() *C.QtPrivate__ResultItem {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__ResultItem) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__ResultItem constructs the type using only CGO pointers.
func newQtPrivate__ResultItem(h *C.QtPrivate__ResultItem) *QtPrivate__ResultItem {
if h == nil {
return nil
}
return &QtPrivate__ResultItem{h: h}
}
// UnsafeNewQtPrivate__ResultItem constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__ResultItem(h unsafe.Pointer) *QtPrivate__ResultItem {
if h == nil {
return nil
}
return &QtPrivate__ResultItem{h: (*C.QtPrivate__ResultItem)(h)}
}
// NewQtPrivate__ResultItem constructs a new QtPrivate::ResultItem object.
func NewQtPrivate__ResultItem(_result unsafe.Pointer, _count int) *QtPrivate__ResultItem {
var outptr_QtPrivate__ResultItem *C.QtPrivate__ResultItem = nil
C.QtPrivate__ResultItem_new(_result, (C.int)(_count), &outptr_QtPrivate__ResultItem)
ret := newQtPrivate__ResultItem(outptr_QtPrivate__ResultItem)
ret.isSubclass = true
return ret
}
// NewQtPrivate__ResultItem2 constructs a new QtPrivate::ResultItem object.
func NewQtPrivate__ResultItem2(_result unsafe.Pointer) *QtPrivate__ResultItem {
var outptr_QtPrivate__ResultItem *C.QtPrivate__ResultItem = nil
C.QtPrivate__ResultItem_new2(_result, &outptr_QtPrivate__ResultItem)
ret := newQtPrivate__ResultItem(outptr_QtPrivate__ResultItem)
ret.isSubclass = true
return ret
}
// NewQtPrivate__ResultItem3 constructs a new QtPrivate::ResultItem object.
func NewQtPrivate__ResultItem3() *QtPrivate__ResultItem {
var outptr_QtPrivate__ResultItem *C.QtPrivate__ResultItem = nil
C.QtPrivate__ResultItem_new3(&outptr_QtPrivate__ResultItem)
ret := newQtPrivate__ResultItem(outptr_QtPrivate__ResultItem)
ret.isSubclass = true
return ret
}
func (this *QtPrivate__ResultItem) IsValid() bool {
return (bool)(C.QtPrivate__ResultItem_IsValid(this.h))
}
func (this *QtPrivate__ResultItem) IsVector() bool {
return (bool)(C.QtPrivate__ResultItem_IsVector(this.h))
}
func (this *QtPrivate__ResultItem) Count() int {
return (int)(C.QtPrivate__ResultItem_Count(this.h))
}
// Delete this object from C++ memory.
func (this *QtPrivate__ResultItem) Delete() {
C.QtPrivate__ResultItem_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__ResultItem) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__ResultItem) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__ResultIteratorBase struct {
h *C.QtPrivate__ResultIteratorBase
isSubclass bool
}
func (this *QtPrivate__ResultIteratorBase) cPointer() *C.QtPrivate__ResultIteratorBase {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__ResultIteratorBase) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__ResultIteratorBase constructs the type using only CGO pointers.
func newQtPrivate__ResultIteratorBase(h *C.QtPrivate__ResultIteratorBase) *QtPrivate__ResultIteratorBase {
if h == nil {
return nil
}
return &QtPrivate__ResultIteratorBase{h: h}
}
// UnsafeNewQtPrivate__ResultIteratorBase constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__ResultIteratorBase(h unsafe.Pointer) *QtPrivate__ResultIteratorBase {
if h == nil {
return nil
}
return &QtPrivate__ResultIteratorBase{h: (*C.QtPrivate__ResultIteratorBase)(h)}
}
// NewQtPrivate__ResultIteratorBase constructs a new QtPrivate::ResultIteratorBase object.
func NewQtPrivate__ResultIteratorBase() *QtPrivate__ResultIteratorBase {
var outptr_QtPrivate__ResultIteratorBase *C.QtPrivate__ResultIteratorBase = nil
C.QtPrivate__ResultIteratorBase_new(&outptr_QtPrivate__ResultIteratorBase)
ret := newQtPrivate__ResultIteratorBase(outptr_QtPrivate__ResultIteratorBase)
ret.isSubclass = true
return ret
}
func (this *QtPrivate__ResultIteratorBase) VectorIndex() int {
return (int)(C.QtPrivate__ResultIteratorBase_VectorIndex(this.h))
}
func (this *QtPrivate__ResultIteratorBase) ResultIndex() int {
return (int)(C.QtPrivate__ResultIteratorBase_ResultIndex(this.h))
}
func (this *QtPrivate__ResultIteratorBase) BatchSize() int {
return (int)(C.QtPrivate__ResultIteratorBase_BatchSize(this.h))
}
func (this *QtPrivate__ResultIteratorBase) BatchedAdvance() {
C.QtPrivate__ResultIteratorBase_BatchedAdvance(this.h)
}
func (this *QtPrivate__ResultIteratorBase) IsVector() bool {
return (bool)(C.QtPrivate__ResultIteratorBase_IsVector(this.h))
}
func (this *QtPrivate__ResultIteratorBase) CanIncrementVectorIndex() bool {
return (bool)(C.QtPrivate__ResultIteratorBase_CanIncrementVectorIndex(this.h))
}
// Delete this object from C++ memory.
func (this *QtPrivate__ResultIteratorBase) Delete() {
C.QtPrivate__ResultIteratorBase_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__ResultIteratorBase) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__ResultIteratorBase) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__ResultStoreBase struct {
h *C.QtPrivate__ResultStoreBase
isSubclass bool
}
func (this *QtPrivate__ResultStoreBase) cPointer() *C.QtPrivate__ResultStoreBase {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__ResultStoreBase) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__ResultStoreBase constructs the type using only CGO pointers.
func newQtPrivate__ResultStoreBase(h *C.QtPrivate__ResultStoreBase) *QtPrivate__ResultStoreBase {
if h == nil {
return nil
}
return &QtPrivate__ResultStoreBase{h: h}
}
// UnsafeNewQtPrivate__ResultStoreBase constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__ResultStoreBase(h unsafe.Pointer) *QtPrivate__ResultStoreBase {
if h == nil {
return nil
}
return &QtPrivate__ResultStoreBase{h: (*C.QtPrivate__ResultStoreBase)(h)}
}
// NewQtPrivate__ResultStoreBase constructs a new QtPrivate::ResultStoreBase object.
func NewQtPrivate__ResultStoreBase() *QtPrivate__ResultStoreBase {
var outptr_QtPrivate__ResultStoreBase *C.QtPrivate__ResultStoreBase = nil
C.QtPrivate__ResultStoreBase_new(&outptr_QtPrivate__ResultStoreBase)
ret := newQtPrivate__ResultStoreBase(outptr_QtPrivate__ResultStoreBase)
ret.isSubclass = true
return ret
}
func (this *QtPrivate__ResultStoreBase) SetFilterMode(enable bool) {
C.QtPrivate__ResultStoreBase_SetFilterMode(this.h, (C.bool)(enable))
}
func (this *QtPrivate__ResultStoreBase) FilterMode() bool {
return (bool)(C.QtPrivate__ResultStoreBase_FilterMode(this.h))
}
func (this *QtPrivate__ResultStoreBase) AddResult(index int, result unsafe.Pointer) int {
return (int)(C.QtPrivate__ResultStoreBase_AddResult(this.h, (C.int)(index), result))
}
func (this *QtPrivate__ResultStoreBase) AddResults(index int, results unsafe.Pointer, vectorSize int, logicalCount int) int {
return (int)(C.QtPrivate__ResultStoreBase_AddResults(this.h, (C.int)(index), results, (C.int)(vectorSize), (C.int)(logicalCount)))
}
func (this *QtPrivate__ResultStoreBase) HasNextResult() bool {
return (bool)(C.QtPrivate__ResultStoreBase_HasNextResult(this.h))
}
func (this *QtPrivate__ResultStoreBase) Contains(index int) bool {
return (bool)(C.QtPrivate__ResultStoreBase_Contains(this.h, (C.int)(index)))
}
func (this *QtPrivate__ResultStoreBase) Count() int {
return (int)(C.QtPrivate__ResultStoreBase_Count(this.h))
}
func (this *QtPrivate__ResultStoreBase) AddCanceledResult(index int) int {
return (int)(C.QtPrivate__ResultStoreBase_AddCanceledResult(this.h, (C.int)(index)))
}
// Delete this object from C++ memory.
func (this *QtPrivate__ResultStoreBase) Delete() {
C.QtPrivate__ResultStoreBase_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__ResultStoreBase) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__ResultStoreBase) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

71
qt/gen_qresultstore.h
View File

@ -1,71 +0,0 @@
#pragma once
#ifndef MIQT_QT_GEN_QRESULTSTORE_H
#define MIQT_QT_GEN_QRESULTSTORE_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ResultItem)
typedef QtPrivate::ResultItem QtPrivate__ResultItem;
#else
class QtPrivate__ResultItem;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ResultIteratorBase)
typedef QtPrivate::ResultIteratorBase QtPrivate__ResultIteratorBase;
#else
class QtPrivate__ResultIteratorBase;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ResultStoreBase)
typedef QtPrivate::ResultStoreBase QtPrivate__ResultStoreBase;
#else
class QtPrivate__ResultStoreBase;
#endif
#else
typedef struct QtPrivate__ResultItem QtPrivate__ResultItem;
typedef struct QtPrivate__ResultIteratorBase QtPrivate__ResultIteratorBase;
typedef struct QtPrivate__ResultStoreBase QtPrivate__ResultStoreBase;
#endif
void QtPrivate__ResultItem_new(const void* _result, int _count, QtPrivate__ResultItem** outptr_QtPrivate__ResultItem);
void QtPrivate__ResultItem_new2(const void* _result, QtPrivate__ResultItem** outptr_QtPrivate__ResultItem);
void QtPrivate__ResultItem_new3(QtPrivate__ResultItem** outptr_QtPrivate__ResultItem);
bool QtPrivate__ResultItem_IsValid(const QtPrivate__ResultItem* self);
bool QtPrivate__ResultItem_IsVector(const QtPrivate__ResultItem* self);
int QtPrivate__ResultItem_Count(const QtPrivate__ResultItem* self);
void QtPrivate__ResultItem_Delete(QtPrivate__ResultItem* self, bool isSubclass);
void QtPrivate__ResultIteratorBase_new(QtPrivate__ResultIteratorBase** outptr_QtPrivate__ResultIteratorBase);
int QtPrivate__ResultIteratorBase_VectorIndex(const QtPrivate__ResultIteratorBase* self);
int QtPrivate__ResultIteratorBase_ResultIndex(const QtPrivate__ResultIteratorBase* self);
int QtPrivate__ResultIteratorBase_BatchSize(const QtPrivate__ResultIteratorBase* self);
void QtPrivate__ResultIteratorBase_BatchedAdvance(QtPrivate__ResultIteratorBase* self);
bool QtPrivate__ResultIteratorBase_IsVector(const QtPrivate__ResultIteratorBase* self);
bool QtPrivate__ResultIteratorBase_CanIncrementVectorIndex(const QtPrivate__ResultIteratorBase* self);
void QtPrivate__ResultIteratorBase_Delete(QtPrivate__ResultIteratorBase* self, bool isSubclass);
void QtPrivate__ResultStoreBase_new(QtPrivate__ResultStoreBase** outptr_QtPrivate__ResultStoreBase);
void QtPrivate__ResultStoreBase_SetFilterMode(QtPrivate__ResultStoreBase* self, bool enable);
bool QtPrivate__ResultStoreBase_FilterMode(const QtPrivate__ResultStoreBase* self);
int QtPrivate__ResultStoreBase_AddResult(QtPrivate__ResultStoreBase* self, int index, const void* result);
int QtPrivate__ResultStoreBase_AddResults(QtPrivate__ResultStoreBase* self, int index, const void* results, int vectorSize, int logicalCount);
bool QtPrivate__ResultStoreBase_HasNextResult(const QtPrivate__ResultStoreBase* self);
bool QtPrivate__ResultStoreBase_Contains(const QtPrivate__ResultStoreBase* self, int index);
int QtPrivate__ResultStoreBase_Count(const QtPrivate__ResultStoreBase* self);
int QtPrivate__ResultStoreBase_AddCanceledResult(QtPrivate__ResultStoreBase* self, int index);
void QtPrivate__ResultStoreBase_Delete(QtPrivate__ResultStoreBase* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

2
qt/gen_qsocketnotifier.cpp
View File

@ -238,7 +238,7 @@ struct miqt_string QSocketNotifier_TrUtf8(const char* s) {
intptr_t QSocketNotifier_Socket(const QSocketNotifier* self) {
qintptr _ret = self->socket();
return static_cast<intptr_t>(_ret);
return (intptr_t)(_ret);
}
int QSocketNotifier_Type(const QSocketNotifier* self) {

23
qt/gen_qvariant.cpp
View File

@ -34,7 +34,6 @@
#include <QUuid>
#include <QVariant>
#define WORKAROUND_INNER_CLASS_DEFINITION_QVariant__Handler
#define WORKAROUND_INNER_CLASS_DEFINITION_QVariant__Private__Data
#include <QVariantComparisonHelper>
#include <qvariant.h>
#include "gen_qvariant.h"
@ -670,28 +669,6 @@ void QVariantComparisonHelper_Delete(QVariantComparisonHelper* self, bool isSubc
}
}
void QVariant__Private__Data_new(QVariant__Private__Data** outptr_QVariant__Private__Data) {
QVariant::Private::Data* ret = new QVariant::Private::Data();
*outptr_QVariant__Private__Data = ret;
}
void QVariant__Private__Data_new2(QVariant__Private__Data* param1, QVariant__Private__Data** outptr_QVariant__Private__Data) {
QVariant::Private::Data* ret = new QVariant::Private::Data(*param1);
*outptr_QVariant__Private__Data = ret;
}
void QVariant__Private__Data_OperatorAssign(QVariant__Private__Data* self, QVariant__Private__Data* param1) {
self->operator=(*param1);
}
void QVariant__Private__Data_Delete(QVariant__Private__Data* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QVariant::Private::Data*>( self );
} else {
delete self;
}
}
void QVariant__Handler_Delete(QVariant__Handler* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QVariant::Handler*>( self );

74
qt/gen_qvariant.go
View File

@ -1103,80 +1103,6 @@ func (this *QVariantComparisonHelper) GoGC() {
})
}
type QVariant__Private__Data struct {
h *C.QVariant__Private__Data
isSubclass bool
}
func (this *QVariant__Private__Data) cPointer() *C.QVariant__Private__Data {
if this == nil {
return nil
}
return this.h
}
func (this *QVariant__Private__Data) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQVariant__Private__Data constructs the type using only CGO pointers.
func newQVariant__Private__Data(h *C.QVariant__Private__Data) *QVariant__Private__Data {
if h == nil {
return nil
}
return &QVariant__Private__Data{h: h}
}
// UnsafeNewQVariant__Private__Data constructs the type using only unsafe pointers.
func UnsafeNewQVariant__Private__Data(h unsafe.Pointer) *QVariant__Private__Data {
if h == nil {
return nil
}
return &QVariant__Private__Data{h: (*C.QVariant__Private__Data)(h)}
}
// NewQVariant__Private__Data constructs a new QVariant::Private::Data object.
func NewQVariant__Private__Data() *QVariant__Private__Data {
var outptr_QVariant__Private__Data *C.QVariant__Private__Data = nil
C.QVariant__Private__Data_new(&outptr_QVariant__Private__Data)
ret := newQVariant__Private__Data(outptr_QVariant__Private__Data)
ret.isSubclass = true
return ret
}
// NewQVariant__Private__Data2 constructs a new QVariant::Private::Data object.
func NewQVariant__Private__Data2(param1 *QVariant__Private__Data) *QVariant__Private__Data {
var outptr_QVariant__Private__Data *C.QVariant__Private__Data = nil
C.QVariant__Private__Data_new2(param1.cPointer(), &outptr_QVariant__Private__Data)
ret := newQVariant__Private__Data(outptr_QVariant__Private__Data)
ret.isSubclass = true
return ret
}
func (this *QVariant__Private__Data) OperatorAssign(param1 *QVariant__Private__Data) {
C.QVariant__Private__Data_OperatorAssign(this.h, param1.cPointer())
}
// Delete this object from C++ memory.
func (this *QVariant__Private__Data) Delete() {
C.QVariant__Private__Data_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QVariant__Private__Data) GoGC() {
runtime.SetFinalizer(this, func(this *QVariant__Private__Data) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QVariant__Handler struct {
h *C.QVariant__Handler
isSubclass bool

11
qt/gen_qvariant.h
View File

@ -58,11 +58,6 @@ typedef QVariant::Handler QVariant__Handler;
#else
class QVariant__Handler;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QVariant__Private__Data)
typedef QVariant::Private::Data QVariant__Private__Data;
#else
class QVariant__Private__Data;
#endif
class QVariantComparisonHelper;
#else
typedef struct QAssociativeIterable__const_iterator QAssociativeIterable__const_iterator;
@ -96,7 +91,6 @@ typedef struct QUrl QUrl;
typedef struct QUuid QUuid;
typedef struct QVariant QVariant;
typedef struct QVariant__Handler QVariant__Handler;
typedef struct QVariant__Private__Data QVariant__Private__Data;
typedef struct QVariantComparisonHelper QVariantComparisonHelper;
#endif
@ -220,11 +214,6 @@ void QVariantComparisonHelper_new(QVariant* varVal, QVariantComparisonHelper** o
void QVariantComparisonHelper_new2(QVariantComparisonHelper* param1, QVariantComparisonHelper** outptr_QVariantComparisonHelper);
void QVariantComparisonHelper_Delete(QVariantComparisonHelper* self, bool isSubclass);
void QVariant__Private__Data_new(QVariant__Private__Data** outptr_QVariant__Private__Data);
void QVariant__Private__Data_new2(QVariant__Private__Data* param1, QVariant__Private__Data** outptr_QVariant__Private__Data);
void QVariant__Private__Data_OperatorAssign(QVariant__Private__Data* self, QVariant__Private__Data* param1);
void QVariant__Private__Data_Delete(QVariant__Private__Data* self, bool isSubclass);
void QVariant__Handler_Delete(QVariant__Handler* self, bool isSubclass);
void QSequentialIterable__const_iterator_new(QSequentialIterable__const_iterator* other, QSequentialIterable__const_iterator** outptr_QSequentialIterable__const_iterator);

6
qt/network/gen_qabstractsocket.cpp
View File

@ -246,7 +246,7 @@ public:
intptr_t virtualbase_SocketDescriptor() const {
qintptr _ret = QAbstractSocket::socketDescriptor();
return static_cast<intptr_t>(_ret);
return (intptr_t)(_ret);
}
@ -260,7 +260,7 @@ public:
}
qintptr socketDescriptor_ret = socketDescriptor;
intptr_t sigval1 = static_cast<intptr_t>(socketDescriptor_ret);
intptr_t sigval1 = (intptr_t)(socketDescriptor_ret);
QAbstractSocket::SocketState state_ret = state;
int sigval2 = static_cast<int>(state_ret);
QIODevice::OpenMode openMode_ret = openMode;
@ -818,7 +818,7 @@ void QAbstractSocket_Abort(QAbstractSocket* self) {
intptr_t QAbstractSocket_SocketDescriptor(const QAbstractSocket* self) {
qintptr _ret = self->socketDescriptor();
return static_cast<intptr_t>(_ret);
return (intptr_t)(_ret);
}
bool QAbstractSocket_SetSocketDescriptor(QAbstractSocket* self, intptr_t socketDescriptor, int state, int openMode) {

2
qt/network/gen_qlocalserver.cpp
View File

@ -406,7 +406,7 @@ int QLocalServer_SocketOptions(const QLocalServer* self) {
intptr_t QLocalServer_SocketDescriptor(const QLocalServer* self) {
qintptr _ret = self->socketDescriptor();
return static_cast<intptr_t>(_ret);
return (intptr_t)(_ret);
}
struct miqt_string QLocalServer_Tr2(const char* s, const char* c) {

2
qt/network/gen_qlocalsocket.cpp
View File

@ -536,7 +536,7 @@ bool QLocalSocket_SetSocketDescriptor(QLocalSocket* self, intptr_t socketDescrip
intptr_t QLocalSocket_SocketDescriptor(const QLocalSocket* self) {
qintptr _ret = self->socketDescriptor();
return static_cast<intptr_t>(_ret);
return (intptr_t)(_ret);
}
int QLocalSocket_State(const QLocalSocket* self) {

2
qt/network/gen_qsslsocket.cpp
View File

@ -62,7 +62,7 @@ public:
}
qintptr socketDescriptor_ret = socketDescriptor;
intptr_t sigval1 = static_cast<intptr_t>(socketDescriptor_ret);
intptr_t sigval1 = (intptr_t)(socketDescriptor_ret);
QAbstractSocket::SocketState state_ret = state;
int sigval2 = static_cast<int>(state_ret);
QIODevice::OpenMode openMode_ret = openMode;

4
qt/network/gen_qtcpserver.cpp
View File

@ -78,7 +78,7 @@ public:
}
qintptr handle_ret = handle;
intptr_t sigval1 = static_cast<intptr_t>(handle_ret);
intptr_t sigval1 = (intptr_t)(handle_ret);
miqt_exec_callback_QTcpServer_IncomingConnection(this, handle__IncomingConnection, sigval1);
@ -338,7 +338,7 @@ QHostAddress* QTcpServer_ServerAddress(const QTcpServer* self) {
intptr_t QTcpServer_SocketDescriptor(const QTcpServer* self) {
qintptr _ret = self->socketDescriptor();
return static_cast<intptr_t>(_ret);
return (intptr_t)(_ret);
}
bool QTcpServer_SetSocketDescriptor(QTcpServer* self, intptr_t socketDescriptor) {

4
qt/network/gen_qtcpsocket.cpp
View File

@ -215,7 +215,7 @@ public:
intptr_t virtualbase_SocketDescriptor() const {
qintptr _ret = QTcpSocket::socketDescriptor();
return static_cast<intptr_t>(_ret);
return (intptr_t)(_ret);
}
@ -229,7 +229,7 @@ public:
}
qintptr socketDescriptor_ret = socketDescriptor;
intptr_t sigval1 = static_cast<intptr_t>(socketDescriptor_ret);
intptr_t sigval1 = (intptr_t)(socketDescriptor_ret);
QAbstractSocket::SocketState state_ret = state;
int sigval2 = static_cast<int>(state_ret);
QIODevice::OpenMode openMode_ret = openMode;

4
qt/network/gen_qudpsocket.cpp
View File

@ -219,7 +219,7 @@ public:
intptr_t virtualbase_SocketDescriptor() const {
qintptr _ret = QUdpSocket::socketDescriptor();
return static_cast<intptr_t>(_ret);
return (intptr_t)(_ret);
}
@ -233,7 +233,7 @@ public:
}
qintptr socketDescriptor_ret = socketDescriptor;
intptr_t sigval1 = static_cast<intptr_t>(socketDescriptor_ret);
intptr_t sigval1 = (intptr_t)(socketDescriptor_ret);
QAbstractSocket::SocketState state_ret = state;
int sigval2 = static_cast<int>(state_ret);
QIODevice::OpenMode openMode_ret = openMode;

2
qt6/gen_qabstractslider.cpp
View File

@ -891,7 +891,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QAbstractSlider_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qabstractspinbox.cpp
View File

@ -1050,7 +1050,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QAbstractSpinBox_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

9
qt6/gen_qarraydata.cpp
View File

@ -1,5 +1,4 @@
#include <QArrayData>
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QContainerImplHelper
#include <qarraydata.h>
#include "gen_qarraydata.h"
#include "_cgo_export.h"
@ -67,11 +66,3 @@ void QArrayData_Delete(QArrayData* self, bool isSubclass) {
}
}
void QtPrivate__QContainerImplHelper_Delete(QtPrivate__QContainerImplHelper* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QContainerImplHelper*>( self );
} else {
delete self;
}
}

50
qt6/gen_qarraydata.go
View File

@ -140,53 +140,3 @@ func (this *QArrayData) GoGC() {
runtime.KeepAlive(this.h)
})
}
type QtPrivate__QContainerImplHelper struct {
h *C.QtPrivate__QContainerImplHelper
isSubclass bool
}
func (this *QtPrivate__QContainerImplHelper) cPointer() *C.QtPrivate__QContainerImplHelper {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QContainerImplHelper) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QContainerImplHelper constructs the type using only CGO pointers.
func newQtPrivate__QContainerImplHelper(h *C.QtPrivate__QContainerImplHelper) *QtPrivate__QContainerImplHelper {
if h == nil {
return nil
}
return &QtPrivate__QContainerImplHelper{h: h}
}
// UnsafeNewQtPrivate__QContainerImplHelper constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QContainerImplHelper(h unsafe.Pointer) *QtPrivate__QContainerImplHelper {
if h == nil {
return nil
}
return &QtPrivate__QContainerImplHelper{h: (*C.QtPrivate__QContainerImplHelper)(h)}
}
// Delete this object from C++ memory.
func (this *QtPrivate__QContainerImplHelper) Delete() {
C.QtPrivate__QContainerImplHelper_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QContainerImplHelper) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QContainerImplHelper) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

8
qt6/gen_qarraydata.h
View File

@ -16,14 +16,8 @@ extern "C" {
#ifdef __cplusplus
class QArrayData;
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QContainerImplHelper)
typedef QtPrivate::QContainerImplHelper QtPrivate__QContainerImplHelper;
#else
class QtPrivate__QContainerImplHelper;
#endif
#else
typedef struct QArrayData QArrayData;
typedef struct QtPrivate__QContainerImplHelper QtPrivate__QContainerImplHelper;
#endif
ptrdiff_t QArrayData_AllocatedCapacity(QArrayData* self);
@ -37,8 +31,6 @@ struct miqt_map /* tuple of QArrayData* and void* */ QArrayData_ReallocateUnali
void QArrayData_Deallocate(QArrayData* data, ptrdiff_t objectSize, ptrdiff_t alignment);
void QArrayData_Delete(QArrayData* self, bool isSubclass);
void QtPrivate__QContainerImplHelper_Delete(QtPrivate__QContainerImplHelper* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif

2
qt6/gen_qcalendarwidget.cpp
View File

@ -874,7 +874,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QCalendarWidget_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qcombobox.cpp
View File

@ -993,7 +993,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QComboBox_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

14
qt6/gen_qdatastream.cpp
View File

@ -2,7 +2,6 @@
#include <QDataStream>
#include <QIODevice>
#include <QIODeviceBase>
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__StreamStateSaver
#include <qdatastream.h>
#include "gen_qdatastream.h"
#include "_cgo_export.h"
@ -231,16 +230,3 @@ void QDataStream_Delete(QDataStream* self, bool isSubclass) {
}
}
void QtPrivate__StreamStateSaver_new(QDataStream* s, QtPrivate__StreamStateSaver** outptr_QtPrivate__StreamStateSaver) {
QtPrivate::StreamStateSaver* ret = new QtPrivate::StreamStateSaver(s);
*outptr_QtPrivate__StreamStateSaver = ret;
}
void QtPrivate__StreamStateSaver_Delete(QtPrivate__StreamStateSaver* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::StreamStateSaver*>( self );
} else {
delete self;
}
}

60
qt6/gen_qdatastream.go
View File

@ -371,63 +371,3 @@ func (this *QDataStream) GoGC() {
runtime.KeepAlive(this.h)
})
}
type QtPrivate__StreamStateSaver struct {
h *C.QtPrivate__StreamStateSaver
isSubclass bool
}
func (this *QtPrivate__StreamStateSaver) cPointer() *C.QtPrivate__StreamStateSaver {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__StreamStateSaver) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__StreamStateSaver constructs the type using only CGO pointers.
func newQtPrivate__StreamStateSaver(h *C.QtPrivate__StreamStateSaver) *QtPrivate__StreamStateSaver {
if h == nil {
return nil
}
return &QtPrivate__StreamStateSaver{h: h}
}
// UnsafeNewQtPrivate__StreamStateSaver constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__StreamStateSaver(h unsafe.Pointer) *QtPrivate__StreamStateSaver {
if h == nil {
return nil
}
return &QtPrivate__StreamStateSaver{h: (*C.QtPrivate__StreamStateSaver)(h)}
}
// NewQtPrivate__StreamStateSaver constructs a new QtPrivate::StreamStateSaver object.
func NewQtPrivate__StreamStateSaver(s *QDataStream) *QtPrivate__StreamStateSaver {
var outptr_QtPrivate__StreamStateSaver *C.QtPrivate__StreamStateSaver = nil
C.QtPrivate__StreamStateSaver_new(s.cPointer(), &outptr_QtPrivate__StreamStateSaver)
ret := newQtPrivate__StreamStateSaver(outptr_QtPrivate__StreamStateSaver)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtPrivate__StreamStateSaver) Delete() {
C.QtPrivate__StreamStateSaver_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__StreamStateSaver) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__StreamStateSaver) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

9
qt6/gen_qdatastream.h
View File

@ -19,17 +19,11 @@ class QByteArray;
class QDataStream;
class QIODevice;
class QIODeviceBase;
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__StreamStateSaver)
typedef QtPrivate::StreamStateSaver QtPrivate__StreamStateSaver;
#else
class QtPrivate__StreamStateSaver;
#endif
#else
typedef struct QByteArray QByteArray;
typedef struct QDataStream QDataStream;
typedef struct QIODevice QIODevice;
typedef struct QIODeviceBase QIODeviceBase;
typedef struct QtPrivate__StreamStateSaver QtPrivate__StreamStateSaver;
#endif
void QDataStream_new(QDataStream** outptr_QDataStream, QIODeviceBase** outptr_QIODeviceBase);
@ -85,9 +79,6 @@ void QDataStream_AbortTransaction(QDataStream* self);
bool QDataStream_IsDeviceTransactionStarted(const QDataStream* self);
void QDataStream_Delete(QDataStream* self, bool isSubclass);
void QtPrivate__StreamStateSaver_new(QDataStream* s, QtPrivate__StreamStateSaver** outptr_QtPrivate__StreamStateSaver);
void QtPrivate__StreamStateSaver_Delete(QtPrivate__StreamStateSaver* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif

2
qt6/gen_qdialog.cpp
View File

@ -957,7 +957,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QDialog_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qdialogbuttonbox.cpp
View File

@ -850,7 +850,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QDialogButtonBox_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qdockwidget.cpp
View File

@ -871,7 +871,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QDockWidget_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

25
qt6/gen_qexception.cpp
View File

@ -1,25 +0,0 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ExceptionStore
#include <qexception.h>
#include "gen_qexception.h"
#include "_cgo_export.h"
bool QtPrivate__ExceptionStore_HasException(const QtPrivate__ExceptionStore* self) {
return self->hasException();
}
void QtPrivate__ExceptionStore_ThrowPossibleException(QtPrivate__ExceptionStore* self) {
self->throwPossibleException();
}
void QtPrivate__ExceptionStore_RethrowException(const QtPrivate__ExceptionStore* self) {
self->rethrowException();
}
void QtPrivate__ExceptionStore_Delete(QtPrivate__ExceptionStore* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::ExceptionStore*>( self );
} else {
delete self;
}
}

76
qt6/gen_qexception.go
View File

@ -1,76 +0,0 @@
package qt6
/*
#include "gen_qexception.h"
#include <stdlib.h>
*/
import "C"
import (
"runtime"
"unsafe"
)
type QtPrivate__ExceptionStore struct {
h *C.QtPrivate__ExceptionStore
isSubclass bool
}
func (this *QtPrivate__ExceptionStore) cPointer() *C.QtPrivate__ExceptionStore {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__ExceptionStore) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__ExceptionStore constructs the type using only CGO pointers.
func newQtPrivate__ExceptionStore(h *C.QtPrivate__ExceptionStore) *QtPrivate__ExceptionStore {
if h == nil {
return nil
}
return &QtPrivate__ExceptionStore{h: h}
}
// UnsafeNewQtPrivate__ExceptionStore constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__ExceptionStore(h unsafe.Pointer) *QtPrivate__ExceptionStore {
if h == nil {
return nil
}
return &QtPrivate__ExceptionStore{h: (*C.QtPrivate__ExceptionStore)(h)}
}
func (this *QtPrivate__ExceptionStore) HasException() bool {
return (bool)(C.QtPrivate__ExceptionStore_HasException(this.h))
}
func (this *QtPrivate__ExceptionStore) ThrowPossibleException() {
C.QtPrivate__ExceptionStore_ThrowPossibleException(this.h)
}
func (this *QtPrivate__ExceptionStore) RethrowException() {
C.QtPrivate__ExceptionStore_RethrowException(this.h)
}
// Delete this object from C++ memory.
func (this *QtPrivate__ExceptionStore) Delete() {
C.QtPrivate__ExceptionStore_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__ExceptionStore) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__ExceptionStore) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

36
qt6/gen_qexception.h
View File

@ -1,36 +0,0 @@
#pragma once
#ifndef MIQT_QT6_GEN_QEXCEPTION_H
#define MIQT_QT6_GEN_QEXCEPTION_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ExceptionStore)
typedef QtPrivate::ExceptionStore QtPrivate__ExceptionStore;
#else
class QtPrivate__ExceptionStore;
#endif
#else
typedef struct QtPrivate__ExceptionStore QtPrivate__ExceptionStore;
#endif
bool QtPrivate__ExceptionStore_HasException(const QtPrivate__ExceptionStore* self);
void QtPrivate__ExceptionStore_ThrowPossibleException(QtPrivate__ExceptionStore* self);
void QtPrivate__ExceptionStore_RethrowException(const QtPrivate__ExceptionStore* self);
void QtPrivate__ExceptionStore_Delete(QtPrivate__ExceptionStore* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

2
qt6/gen_qfocusframe.cpp
View File

@ -866,7 +866,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QFocusFrame_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qframe.cpp
View File

@ -868,7 +868,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QFrame_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qgroupbox.cpp
View File

@ -893,7 +893,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QGroupBox_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

28
qt6/gen_qhashfunctions.cpp
View File

@ -1,6 +1,4 @@
#include <QHashSeed>
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QHashCombine
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QHashCombineCommutative
#include <qhashfunctions.h>
#include "gen_qhashfunctions.h"
#include "_cgo_export.h"
@ -35,29 +33,3 @@ void QHashSeed_Delete(QHashSeed* self, bool isSubclass) {
}
}
void QtPrivate__QHashCombine_new(QtPrivate__QHashCombine** outptr_QtPrivate__QHashCombine) {
QtPrivate::QHashCombine* ret = new QtPrivate::QHashCombine();
*outptr_QtPrivate__QHashCombine = ret;
}
void QtPrivate__QHashCombine_Delete(QtPrivate__QHashCombine* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QHashCombine*>( self );
} else {
delete self;
}
}
void QtPrivate__QHashCombineCommutative_new(QtPrivate__QHashCombineCommutative** outptr_QtPrivate__QHashCombineCommutative) {
QtPrivate::QHashCombineCommutative* ret = new QtPrivate::QHashCombineCommutative();
*outptr_QtPrivate__QHashCombineCommutative = ret;
}
void QtPrivate__QHashCombineCommutative_Delete(QtPrivate__QHashCombineCommutative* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QHashCombineCommutative*>( self );
} else {
delete self;
}
}

120
qt6/gen_qhashfunctions.go
View File

@ -97,123 +97,3 @@ func (this *QHashSeed) GoGC() {
runtime.KeepAlive(this.h)
})
}
type QtPrivate__QHashCombine struct {
h *C.QtPrivate__QHashCombine
isSubclass bool
}
func (this *QtPrivate__QHashCombine) cPointer() *C.QtPrivate__QHashCombine {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QHashCombine) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QHashCombine constructs the type using only CGO pointers.
func newQtPrivate__QHashCombine(h *C.QtPrivate__QHashCombine) *QtPrivate__QHashCombine {
if h == nil {
return nil
}
return &QtPrivate__QHashCombine{h: h}
}
// UnsafeNewQtPrivate__QHashCombine constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QHashCombine(h unsafe.Pointer) *QtPrivate__QHashCombine {
if h == nil {
return nil
}
return &QtPrivate__QHashCombine{h: (*C.QtPrivate__QHashCombine)(h)}
}
// NewQtPrivate__QHashCombine constructs a new QtPrivate::QHashCombine object.
func NewQtPrivate__QHashCombine() *QtPrivate__QHashCombine {
var outptr_QtPrivate__QHashCombine *C.QtPrivate__QHashCombine = nil
C.QtPrivate__QHashCombine_new(&outptr_QtPrivate__QHashCombine)
ret := newQtPrivate__QHashCombine(outptr_QtPrivate__QHashCombine)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtPrivate__QHashCombine) Delete() {
C.QtPrivate__QHashCombine_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QHashCombine) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QHashCombine) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__QHashCombineCommutative struct {
h *C.QtPrivate__QHashCombineCommutative
isSubclass bool
}
func (this *QtPrivate__QHashCombineCommutative) cPointer() *C.QtPrivate__QHashCombineCommutative {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QHashCombineCommutative) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QHashCombineCommutative constructs the type using only CGO pointers.
func newQtPrivate__QHashCombineCommutative(h *C.QtPrivate__QHashCombineCommutative) *QtPrivate__QHashCombineCommutative {
if h == nil {
return nil
}
return &QtPrivate__QHashCombineCommutative{h: h}
}
// UnsafeNewQtPrivate__QHashCombineCommutative constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QHashCombineCommutative(h unsafe.Pointer) *QtPrivate__QHashCombineCommutative {
if h == nil {
return nil
}
return &QtPrivate__QHashCombineCommutative{h: (*C.QtPrivate__QHashCombineCommutative)(h)}
}
// NewQtPrivate__QHashCombineCommutative constructs a new QtPrivate::QHashCombineCommutative object.
func NewQtPrivate__QHashCombineCommutative() *QtPrivate__QHashCombineCommutative {
var outptr_QtPrivate__QHashCombineCommutative *C.QtPrivate__QHashCombineCommutative = nil
C.QtPrivate__QHashCombineCommutative_new(&outptr_QtPrivate__QHashCombineCommutative)
ret := newQtPrivate__QHashCombineCommutative(outptr_QtPrivate__QHashCombineCommutative)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtPrivate__QHashCombineCommutative) Delete() {
C.QtPrivate__QHashCombineCommutative_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QHashCombineCommutative) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QHashCombineCommutative) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

18
qt6/gen_qhashfunctions.h
View File

@ -16,20 +16,8 @@ extern "C" {
#ifdef __cplusplus
class QHashSeed;
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QHashCombine)
typedef QtPrivate::QHashCombine QtPrivate__QHashCombine;
#else
class QtPrivate__QHashCombine;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QHashCombineCommutative)
typedef QtPrivate::QHashCombineCommutative QtPrivate__QHashCombineCommutative;
#else
class QtPrivate__QHashCombineCommutative;
#endif
#else
typedef struct QHashSeed QHashSeed;
typedef struct QtPrivate__QHashCombine QtPrivate__QHashCombine;
typedef struct QtPrivate__QHashCombineCommutative QtPrivate__QHashCombineCommutative;
#endif
void QHashSeed_new(QHashSeed** outptr_QHashSeed);
@ -39,12 +27,6 @@ void QHashSeed_SetDeterministicGlobalSeed();
void QHashSeed_ResetRandomGlobalSeed();
void QHashSeed_Delete(QHashSeed* self, bool isSubclass);
void QtPrivate__QHashCombine_new(QtPrivate__QHashCombine** outptr_QtPrivate__QHashCombine);
void QtPrivate__QHashCombine_Delete(QtPrivate__QHashCombine* self, bool isSubclass);
void QtPrivate__QHashCombineCommutative_new(QtPrivate__QHashCombineCommutative** outptr_QtPrivate__QHashCombineCommutative);
void QtPrivate__QHashCombineCommutative_Delete(QtPrivate__QHashCombineCommutative* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif

2
qt6/gen_qkeysequenceedit.cpp
View File

@ -845,7 +845,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QKeySequenceEdit_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qlineedit.cpp
View File

@ -947,7 +947,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QLineEdit_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qmainwindow.cpp
View File

@ -846,7 +846,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QMainWindow_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qmdisubwindow.cpp
View File

@ -918,7 +918,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QMdiSubWindow_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qmenu.cpp
View File

@ -921,7 +921,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QMenu_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qmenubar.cpp
View File

@ -920,7 +920,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QMenuBar_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

63
qt6/gen_qmetacontainer.cpp
View File

@ -2,65 +2,16 @@
#include <QMetaContainer>
#include <QMetaSequence>
#include <QMetaType>
#define WORKAROUND_INNER_CLASS_DEFINITION_QtMetaContainerPrivate__QMetaAssociationInterface
#define WORKAROUND_INNER_CLASS_DEFINITION_QtMetaContainerPrivate__QMetaContainerInterface
#define WORKAROUND_INNER_CLASS_DEFINITION_QtMetaContainerPrivate__QMetaSequenceInterface
#include <qmetacontainer.h>
#include "gen_qmetacontainer.h"
#include "_cgo_export.h"
void QtMetaContainerPrivate__QMetaContainerInterface_new(QtMetaContainerPrivate__QMetaContainerInterface** outptr_QtMetaContainerPrivate__QMetaContainerInterface) {
QtMetaContainerPrivate::QMetaContainerInterface* ret = new QtMetaContainerPrivate::QMetaContainerInterface();
*outptr_QtMetaContainerPrivate__QMetaContainerInterface = ret;
}
void QtMetaContainerPrivate__QMetaContainerInterface_Delete(QtMetaContainerPrivate__QMetaContainerInterface* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtMetaContainerPrivate::QMetaContainerInterface*>( self );
} else {
delete self;
}
}
void QtMetaContainerPrivate__QMetaSequenceInterface_new(QtMetaContainerPrivate__QMetaSequenceInterface** outptr_QtMetaContainerPrivate__QMetaSequenceInterface, QtMetaContainerPrivate__QMetaContainerInterface** outptr_QtMetaContainerPrivate__QMetaContainerInterface) {
QtMetaContainerPrivate::QMetaSequenceInterface* ret = new QtMetaContainerPrivate::QMetaSequenceInterface();
*outptr_QtMetaContainerPrivate__QMetaSequenceInterface = ret;
*outptr_QtMetaContainerPrivate::QMetaContainerInterface = static_cast<QtMetaContainerPrivate::QMetaContainerInterface*>(ret);
}
void QtMetaContainerPrivate__QMetaSequenceInterface_Delete(QtMetaContainerPrivate__QMetaSequenceInterface* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtMetaContainerPrivate::QMetaSequenceInterface*>( self );
} else {
delete self;
}
}
void QtMetaContainerPrivate__QMetaAssociationInterface_new(QtMetaContainerPrivate__QMetaAssociationInterface** outptr_QtMetaContainerPrivate__QMetaAssociationInterface, QtMetaContainerPrivate__QMetaContainerInterface** outptr_QtMetaContainerPrivate__QMetaContainerInterface) {
QtMetaContainerPrivate::QMetaAssociationInterface* ret = new QtMetaContainerPrivate::QMetaAssociationInterface();
*outptr_QtMetaContainerPrivate__QMetaAssociationInterface = ret;
*outptr_QtMetaContainerPrivate::QMetaContainerInterface = static_cast<QtMetaContainerPrivate::QMetaContainerInterface*>(ret);
}
void QtMetaContainerPrivate__QMetaAssociationInterface_Delete(QtMetaContainerPrivate__QMetaAssociationInterface* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtMetaContainerPrivate::QMetaAssociationInterface*>( self );
} else {
delete self;
}
}
void QMetaContainer_new(QMetaContainer** outptr_QMetaContainer) {
QMetaContainer* ret = new QMetaContainer();
*outptr_QMetaContainer = ret;
}
void QMetaContainer_new2(QtMetaContainerPrivate__QMetaContainerInterface* d, QMetaContainer** outptr_QMetaContainer) {
QMetaContainer* ret = new QMetaContainer(d);
*outptr_QMetaContainer = ret;
}
void QMetaContainer_new3(QMetaContainer* param1, QMetaContainer** outptr_QMetaContainer) {
void QMetaContainer_new2(QMetaContainer* param1, QMetaContainer** outptr_QMetaContainer) {
QMetaContainer* ret = new QMetaContainer(*param1);
*outptr_QMetaContainer = ret;
}
@ -178,12 +129,6 @@ void QMetaSequence_new(QMetaSequence** outptr_QMetaSequence, QMetaContainer** ou
*outptr_QMetaContainer = static_cast<QMetaContainer*>(ret);
}
void QMetaSequence_new2(QtMetaContainerPrivate__QMetaSequenceInterface* d, QMetaSequence** outptr_QMetaSequence, QMetaContainer** outptr_QMetaContainer) {
QMetaSequence* ret = new QMetaSequence(d);
*outptr_QMetaSequence = ret;
*outptr_QMetaContainer = static_cast<QMetaContainer*>(ret);
}
QMetaType* QMetaSequence_ValueMetaType(const QMetaSequence* self) {
return new QMetaType(self->valueMetaType());
}
@ -318,12 +263,6 @@ void QMetaAssociation_new(QMetaAssociation** outptr_QMetaAssociation, QMetaConta
*outptr_QMetaContainer = static_cast<QMetaContainer*>(ret);
}
void QMetaAssociation_new2(QtMetaContainerPrivate__QMetaAssociationInterface* d, QMetaAssociation** outptr_QMetaAssociation, QMetaContainer** outptr_QMetaContainer) {
QMetaAssociation* ret = new QMetaAssociation(d);
*outptr_QMetaAssociation = ret;
*outptr_QMetaContainer = static_cast<QMetaContainer*>(ret);
}
QMetaType* QMetaAssociation_KeyMetaType(const QMetaAssociation* self) {
return new QMetaType(self->keyMetaType());
}

620
qt6/gen_qmetacontainer.go
View File

@ -13,807 +13,555 @@ import (
"unsafe"
)
type QtMetaContainerPrivate__IteratorCapability byte
const (
QtMetaContainerPrivate__InputCapability QtMetaContainerPrivate__IteratorCapability = 1
QtMetaContainerPrivate__ForwardCapability QtMetaContainerPrivate__IteratorCapability = 2
QtMetaContainerPrivate__BiDirectionalCapability QtMetaContainerPrivate__IteratorCapability = 4
QtMetaContainerPrivate__RandomAccessCapability QtMetaContainerPrivate__IteratorCapability = 8
type QtMetaContainerPrivate__IteratorCapability byte
const (
QtMetaContainerPrivate__InputCapability QtMetaContainerPrivate__IteratorCapability = 1
QtMetaContainerPrivate__ForwardCapability QtMetaContainerPrivate__IteratorCapability = 2
QtMetaContainerPrivate__BiDirectionalCapability QtMetaContainerPrivate__IteratorCapability = 4
QtMetaContainerPrivate__RandomAccessCapability QtMetaContainerPrivate__IteratorCapability = 8
)
type QtMetaContainerPrivate__AddRemoveCapability byte
type QtMetaContainerPrivate__AddRemoveCapability byte
const (
QtMetaContainerPrivate__CanAddAtBegin QtMetaContainerPrivate__AddRemoveCapability = 1
QtMetaContainerPrivate__CanRemoveAtBegin QtMetaContainerPrivate__AddRemoveCapability = 2
QtMetaContainerPrivate__CanAddAtEnd QtMetaContainerPrivate__AddRemoveCapability = 4
QtMetaContainerPrivate__CanRemoveAtEnd QtMetaContainerPrivate__AddRemoveCapability = 8
const (
QtMetaContainerPrivate__CanAddAtBegin QtMetaContainerPrivate__AddRemoveCapability = 1
QtMetaContainerPrivate__CanRemoveAtBegin QtMetaContainerPrivate__AddRemoveCapability = 2
QtMetaContainerPrivate__CanAddAtEnd QtMetaContainerPrivate__AddRemoveCapability = 4
QtMetaContainerPrivate__CanRemoveAtEnd QtMetaContainerPrivate__AddRemoveCapability = 8
)
type QtMetaContainerPrivate__QMetaContainerInterface__Position byte
type QtMetaContainerPrivate__QMetaContainerInterface__Position byte
const (
QtMetaContainerPrivate__QMetaContainerInterface__AtBegin QtMetaContainerPrivate__QMetaContainerInterface__Position = 0
QtMetaContainerPrivate__QMetaContainerInterface__AtEnd QtMetaContainerPrivate__QMetaContainerInterface__Position = 1
QtMetaContainerPrivate__QMetaContainerInterface__Unspecified QtMetaContainerPrivate__QMetaContainerInterface__Position = 2
const (
QtMetaContainerPrivate__QMetaContainerInterface__AtBegin QtMetaContainerPrivate__QMetaContainerInterface__Position = 0
QtMetaContainerPrivate__QMetaContainerInterface__AtEnd QtMetaContainerPrivate__QMetaContainerInterface__Position = 1
QtMetaContainerPrivate__QMetaContainerInterface__Unspecified QtMetaContainerPrivate__QMetaContainerInterface__Position = 2
)
type QtMetaContainerPrivate__QMetaContainerInterface struct {
h *C.QtMetaContainerPrivate__QMetaContainerInterface
isSubclass bool
}
func (this *QtMetaContainerPrivate__QMetaContainerInterface) cPointer() *C.QtMetaContainerPrivate__QMetaContainerInterface {
if this == nil {
return nil
}
return this.h
}
func (this *QtMetaContainerPrivate__QMetaContainerInterface) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtMetaContainerPrivate__QMetaContainerInterface constructs the type using only CGO pointers.
func newQtMetaContainerPrivate__QMetaContainerInterface(h *C.QtMetaContainerPrivate__QMetaContainerInterface) *QtMetaContainerPrivate__QMetaContainerInterface {
if h == nil {
return nil
}
return &QtMetaContainerPrivate__QMetaContainerInterface{h: h}
}
// UnsafeNewQtMetaContainerPrivate__QMetaContainerInterface constructs the type using only unsafe pointers.
func UnsafeNewQtMetaContainerPrivate__QMetaContainerInterface(h unsafe.Pointer) *QtMetaContainerPrivate__QMetaContainerInterface {
if h == nil {
return nil
}
return &QtMetaContainerPrivate__QMetaContainerInterface{h: (*C.QtMetaContainerPrivate__QMetaContainerInterface)(h)}
}
// NewQtMetaContainerPrivate__QMetaContainerInterface constructs a new QtMetaContainerPrivate::QMetaContainerInterface object.
func NewQtMetaContainerPrivate__QMetaContainerInterface() *QtMetaContainerPrivate__QMetaContainerInterface {
var outptr_QtMetaContainerPrivate__QMetaContainerInterface *C.QtMetaContainerPrivate__QMetaContainerInterface = nil
C.QtMetaContainerPrivate__QMetaContainerInterface_new(&outptr_QtMetaContainerPrivate__QMetaContainerInterface)
ret := newQtMetaContainerPrivate__QMetaContainerInterface(outptr_QtMetaContainerPrivate__QMetaContainerInterface)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtMetaContainerPrivate__QMetaContainerInterface) Delete() {
C.QtMetaContainerPrivate__QMetaContainerInterface_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtMetaContainerPrivate__QMetaContainerInterface) GoGC() {
runtime.SetFinalizer(this, func(this *QtMetaContainerPrivate__QMetaContainerInterface) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtMetaContainerPrivate__QMetaSequenceInterface struct {
h *C.QtMetaContainerPrivate__QMetaSequenceInterface
isSubclass bool
*QtMetaContainerPrivate__QMetaContainerInterface
}
func (this *QtMetaContainerPrivate__QMetaSequenceInterface) cPointer() *C.QtMetaContainerPrivate__QMetaSequenceInterface {
if this == nil {
return nil
}
return this.h
}
func (this *QtMetaContainerPrivate__QMetaSequenceInterface) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtMetaContainerPrivate__QMetaSequenceInterface constructs the type using only CGO pointers.
func newQtMetaContainerPrivate__QMetaSequenceInterface(h *C.QtMetaContainerPrivate__QMetaSequenceInterface, h_QtMetaContainerPrivate__QMetaContainerInterface *C.QtMetaContainerPrivate__QMetaContainerInterface) *QtMetaContainerPrivate__QMetaSequenceInterface {
if h == nil {
return nil
}
return &QtMetaContainerPrivate__QMetaSequenceInterface{h: h,
QtMetaContainerPrivate__QMetaContainerInterface: newQtMetaContainerPrivate__QMetaContainerInterface(h_QtMetaContainerPrivate__QMetaContainerInterface)}
}
// UnsafeNewQtMetaContainerPrivate__QMetaSequenceInterface constructs the type using only unsafe pointers.
func UnsafeNewQtMetaContainerPrivate__QMetaSequenceInterface(h unsafe.Pointer, h_QtMetaContainerPrivate__QMetaContainerInterface unsafe.Pointer) *QtMetaContainerPrivate__QMetaSequenceInterface {
if h == nil {
return nil
}
return &QtMetaContainerPrivate__QMetaSequenceInterface{h: (*C.QtMetaContainerPrivate__QMetaSequenceInterface)(h),
QtMetaContainerPrivate__QMetaContainerInterface: UnsafeNewQtMetaContainerPrivate__QMetaContainerInterface(h_QtMetaContainerPrivate__QMetaContainerInterface)}
}
// NewQtMetaContainerPrivate__QMetaSequenceInterface constructs a new QtMetaContainerPrivate::QMetaSequenceInterface object.
func NewQtMetaContainerPrivate__QMetaSequenceInterface() *QtMetaContainerPrivate__QMetaSequenceInterface {
var outptr_QtMetaContainerPrivate__QMetaSequenceInterface *C.QtMetaContainerPrivate__QMetaSequenceInterface = nil
var outptr_QtMetaContainerPrivate__QMetaContainerInterface *C.QtMetaContainerPrivate::QMetaContainerInterface = nil
C.QtMetaContainerPrivate__QMetaSequenceInterface_new(&outptr_QtMetaContainerPrivate__QMetaSequenceInterface, &outptr_QtMetaContainerPrivate__QMetaContainerInterface)
ret := newQtMetaContainerPrivate__QMetaSequenceInterface(outptr_QtMetaContainerPrivate__QMetaSequenceInterface, outptr_QtMetaContainerPrivate__QMetaContainerInterface)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtMetaContainerPrivate__QMetaSequenceInterface) Delete() {
C.QtMetaContainerPrivate__QMetaSequenceInterface_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtMetaContainerPrivate__QMetaSequenceInterface) GoGC() {
runtime.SetFinalizer(this, func(this *QtMetaContainerPrivate__QMetaSequenceInterface) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtMetaContainerPrivate__QMetaAssociationInterface struct {
h *C.QtMetaContainerPrivate__QMetaAssociationInterface
isSubclass bool
*QtMetaContainerPrivate__QMetaContainerInterface
}
func (this *QtMetaContainerPrivate__QMetaAssociationInterface) cPointer() *C.QtMetaContainerPrivate__QMetaAssociationInterface {
if this == nil {
return nil
}
return this.h
}
func (this *QtMetaContainerPrivate__QMetaAssociationInterface) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtMetaContainerPrivate__QMetaAssociationInterface constructs the type using only CGO pointers.
func newQtMetaContainerPrivate__QMetaAssociationInterface(h *C.QtMetaContainerPrivate__QMetaAssociationInterface, h_QtMetaContainerPrivate__QMetaContainerInterface *C.QtMetaContainerPrivate__QMetaContainerInterface) *QtMetaContainerPrivate__QMetaAssociationInterface {
if h == nil {
return nil
}
return &QtMetaContainerPrivate__QMetaAssociationInterface{h: h,
QtMetaContainerPrivate__QMetaContainerInterface: newQtMetaContainerPrivate__QMetaContainerInterface(h_QtMetaContainerPrivate__QMetaContainerInterface)}
}
// UnsafeNewQtMetaContainerPrivate__QMetaAssociationInterface constructs the type using only unsafe pointers.
func UnsafeNewQtMetaContainerPrivate__QMetaAssociationInterface(h unsafe.Pointer, h_QtMetaContainerPrivate__QMetaContainerInterface unsafe.Pointer) *QtMetaContainerPrivate__QMetaAssociationInterface {
if h == nil {
return nil
}
return &QtMetaContainerPrivate__QMetaAssociationInterface{h: (*C.QtMetaContainerPrivate__QMetaAssociationInterface)(h),
QtMetaContainerPrivate__QMetaContainerInterface: UnsafeNewQtMetaContainerPrivate__QMetaContainerInterface(h_QtMetaContainerPrivate__QMetaContainerInterface)}
}
// NewQtMetaContainerPrivate__QMetaAssociationInterface constructs a new QtMetaContainerPrivate::QMetaAssociationInterface object.
func NewQtMetaContainerPrivate__QMetaAssociationInterface() *QtMetaContainerPrivate__QMetaAssociationInterface {
var outptr_QtMetaContainerPrivate__QMetaAssociationInterface *C.QtMetaContainerPrivate__QMetaAssociationInterface = nil
var outptr_QtMetaContainerPrivate__QMetaContainerInterface *C.QtMetaContainerPrivate::QMetaContainerInterface = nil
C.QtMetaContainerPrivate__QMetaAssociationInterface_new(&outptr_QtMetaContainerPrivate__QMetaAssociationInterface, &outptr_QtMetaContainerPrivate__QMetaContainerInterface)
ret := newQtMetaContainerPrivate__QMetaAssociationInterface(outptr_QtMetaContainerPrivate__QMetaAssociationInterface, outptr_QtMetaContainerPrivate__QMetaContainerInterface)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtMetaContainerPrivate__QMetaAssociationInterface) Delete() {
C.QtMetaContainerPrivate__QMetaAssociationInterface_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtMetaContainerPrivate__QMetaAssociationInterface) GoGC() {
runtime.SetFinalizer(this, func(this *QtMetaContainerPrivate__QMetaAssociationInterface) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QMetaContainer struct {
type QMetaContainer struct {
h *C.QMetaContainer
isSubclass bool
}
}
func (this *QMetaContainer) cPointer() *C.QMetaContainer {
func (this *QMetaContainer) cPointer() *C.QMetaContainer {
if this == nil {
return nil
}
return this.h
}
}
func (this *QMetaContainer) UnsafePointer() unsafe.Pointer {
func (this *QMetaContainer) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
}
// newQMetaContainer constructs the type using only CGO pointers.
func newQMetaContainer(h *C.QMetaContainer) *QMetaContainer {
// newQMetaContainer constructs the type using only CGO pointers.
func newQMetaContainer(h *C.QMetaContainer) *QMetaContainer {
if h == nil {
return nil
}
return &QMetaContainer{h: h}
}
}
// UnsafeNewQMetaContainer constructs the type using only unsafe pointers.
func UnsafeNewQMetaContainer(h unsafe.Pointer) *QMetaContainer {
// UnsafeNewQMetaContainer constructs the type using only unsafe pointers.
func UnsafeNewQMetaContainer(h unsafe.Pointer) *QMetaContainer {
if h == nil {
return nil
}
return &QMetaContainer{h: (*C.QMetaContainer)(h)}
}
}
// NewQMetaContainer constructs a new QMetaContainer object.
func NewQMetaContainer() *QMetaContainer {
// NewQMetaContainer constructs a new QMetaContainer object.
func NewQMetaContainer() *QMetaContainer {
var outptr_QMetaContainer *C.QMetaContainer = nil
C.QMetaContainer_new(&outptr_QMetaContainer)
ret := newQMetaContainer(outptr_QMetaContainer)
ret.isSubclass = true
return ret
}
}
// NewQMetaContainer2 constructs a new QMetaContainer object.
func NewQMetaContainer2(d *QtMetaContainerPrivate__QMetaContainerInterface) *QMetaContainer {
// NewQMetaContainer2 constructs a new QMetaContainer object.
func NewQMetaContainer2(param1 *QMetaContainer) *QMetaContainer {
var outptr_QMetaContainer *C.QMetaContainer = nil
C.QMetaContainer_new2(d.cPointer(), &outptr_QMetaContainer)
C.QMetaContainer_new2(param1.cPointer(), &outptr_QMetaContainer)
ret := newQMetaContainer(outptr_QMetaContainer)
ret.isSubclass = true
return ret
}
}
// NewQMetaContainer3 constructs a new QMetaContainer object.
func NewQMetaContainer3(param1 *QMetaContainer) *QMetaContainer {
var outptr_QMetaContainer *C.QMetaContainer = nil
C.QMetaContainer_new3(param1.cPointer(), &outptr_QMetaContainer)
ret := newQMetaContainer(outptr_QMetaContainer)
ret.isSubclass = true
return ret
}
func (this *QMetaContainer) HasInputIterator() bool {
func (this *QMetaContainer) HasInputIterator() bool {
return (bool)(C.QMetaContainer_HasInputIterator(this.h))
}
func (this *QMetaContainer) HasForwardIterator() bool {
func (this *QMetaContainer) HasForwardIterator() bool {
return (bool)(C.QMetaContainer_HasForwardIterator(this.h))
}
func (this *QMetaContainer) HasBidirectionalIterator() bool {
func (this *QMetaContainer) HasBidirectionalIterator() bool {
return (bool)(C.QMetaContainer_HasBidirectionalIterator(this.h))
}
func (this *QMetaContainer) HasRandomAccessIterator() bool {
func (this *QMetaContainer) HasRandomAccessIterator() bool {
return (bool)(C.QMetaContainer_HasRandomAccessIterator(this.h))
}
func (this *QMetaContainer) HasSize() bool {
func (this *QMetaContainer) HasSize() bool {
return (bool)(C.QMetaContainer_HasSize(this.h))
}
func (this *QMetaContainer) Size(container unsafe.Pointer) int64 {
func (this *QMetaContainer) Size(container unsafe.Pointer) int64 {
return (int64)(C.QMetaContainer_Size(this.h, container))
}
func (this *QMetaContainer) CanClear() bool {
func (this *QMetaContainer) CanClear() bool {
return (bool)(C.QMetaContainer_CanClear(this.h))
}
func (this *QMetaContainer) Clear(container unsafe.Pointer) {
func (this *QMetaContainer) Clear(container unsafe.Pointer) {
C.QMetaContainer_Clear(this.h, container)
}
func (this *QMetaContainer) HasIterator() bool {
func (this *QMetaContainer) HasIterator() bool {
return (bool)(C.QMetaContainer_HasIterator(this.h))
}
func (this *QMetaContainer) Begin(container unsafe.Pointer) unsafe.Pointer {
func (this *QMetaContainer) Begin(container unsafe.Pointer) unsafe.Pointer {
return (unsafe.Pointer)(C.QMetaContainer_Begin(this.h, container))
}
func (this *QMetaContainer) End(container unsafe.Pointer) unsafe.Pointer {
func (this *QMetaContainer) End(container unsafe.Pointer) unsafe.Pointer {
return (unsafe.Pointer)(C.QMetaContainer_End(this.h, container))
}
func (this *QMetaContainer) DestroyIterator(iterator unsafe.Pointer) {
func (this *QMetaContainer) DestroyIterator(iterator unsafe.Pointer) {
C.QMetaContainer_DestroyIterator(this.h, iterator)
}
func (this *QMetaContainer) CompareIterator(i unsafe.Pointer, j unsafe.Pointer) bool {
func (this *QMetaContainer) CompareIterator(i unsafe.Pointer, j unsafe.Pointer) bool {
return (bool)(C.QMetaContainer_CompareIterator(this.h, i, j))
}
func (this *QMetaContainer) CopyIterator(target unsafe.Pointer, source unsafe.Pointer) {
func (this *QMetaContainer) CopyIterator(target unsafe.Pointer, source unsafe.Pointer) {
C.QMetaContainer_CopyIterator(this.h, target, source)
}
func (this *QMetaContainer) AdvanceIterator(iterator unsafe.Pointer, step int64) {
func (this *QMetaContainer) AdvanceIterator(iterator unsafe.Pointer, step int64) {
C.QMetaContainer_AdvanceIterator(this.h, iterator, (C.ptrdiff_t)(step))
}
func (this *QMetaContainer) DiffIterator(i unsafe.Pointer, j unsafe.Pointer) int64 {
func (this *QMetaContainer) DiffIterator(i unsafe.Pointer, j unsafe.Pointer) int64 {
return (int64)(C.QMetaContainer_DiffIterator(this.h, i, j))
}
func (this *QMetaContainer) HasConstIterator() bool {
func (this *QMetaContainer) HasConstIterator() bool {
return (bool)(C.QMetaContainer_HasConstIterator(this.h))
}
func (this *QMetaContainer) ConstBegin(container unsafe.Pointer) unsafe.Pointer {
func (this *QMetaContainer) ConstBegin(container unsafe.Pointer) unsafe.Pointer {
return (unsafe.Pointer)(C.QMetaContainer_ConstBegin(this.h, container))
}
func (this *QMetaContainer) ConstEnd(container unsafe.Pointer) unsafe.Pointer {
func (this *QMetaContainer) ConstEnd(container unsafe.Pointer) unsafe.Pointer {
return (unsafe.Pointer)(C.QMetaContainer_ConstEnd(this.h, container))
}
func (this *QMetaContainer) DestroyConstIterator(iterator unsafe.Pointer) {
func (this *QMetaContainer) DestroyConstIterator(iterator unsafe.Pointer) {
C.QMetaContainer_DestroyConstIterator(this.h, iterator)
}
func (this *QMetaContainer) CompareConstIterator(i unsafe.Pointer, j unsafe.Pointer) bool {
func (this *QMetaContainer) CompareConstIterator(i unsafe.Pointer, j unsafe.Pointer) bool {
return (bool)(C.QMetaContainer_CompareConstIterator(this.h, i, j))
}
func (this *QMetaContainer) CopyConstIterator(target unsafe.Pointer, source unsafe.Pointer) {
func (this *QMetaContainer) CopyConstIterator(target unsafe.Pointer, source unsafe.Pointer) {
C.QMetaContainer_CopyConstIterator(this.h, target, source)
}
func (this *QMetaContainer) AdvanceConstIterator(iterator unsafe.Pointer, step int64) {
func (this *QMetaContainer) AdvanceConstIterator(iterator unsafe.Pointer, step int64) {
C.QMetaContainer_AdvanceConstIterator(this.h, iterator, (C.ptrdiff_t)(step))
}
func (this *QMetaContainer) DiffConstIterator(i unsafe.Pointer, j unsafe.Pointer) int64 {
func (this *QMetaContainer) DiffConstIterator(i unsafe.Pointer, j unsafe.Pointer) int64 {
return (int64)(C.QMetaContainer_DiffConstIterator(this.h, i, j))
}
// Delete this object from C++ memory.
func (this *QMetaContainer) Delete() {
// Delete this object from C++ memory.
func (this *QMetaContainer) Delete() {
C.QMetaContainer_Delete(this.h, C.bool(this.isSubclass))
}
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QMetaContainer) GoGC() {
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QMetaContainer) GoGC() {
runtime.SetFinalizer(this, func(this *QMetaContainer) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
}
type QMetaSequence struct {
type QMetaSequence struct {
h *C.QMetaSequence
isSubclass bool
*QMetaContainer
}
}
func (this *QMetaSequence) cPointer() *C.QMetaSequence {
func (this *QMetaSequence) cPointer() *C.QMetaSequence {
if this == nil {
return nil
}
return this.h
}
}
func (this *QMetaSequence) UnsafePointer() unsafe.Pointer {
func (this *QMetaSequence) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
}
// newQMetaSequence constructs the type using only CGO pointers.
func newQMetaSequence(h *C.QMetaSequence, h_QMetaContainer *C.QMetaContainer) *QMetaSequence {
// newQMetaSequence constructs the type using only CGO pointers.
func newQMetaSequence(h *C.QMetaSequence, h_QMetaContainer *C.QMetaContainer) *QMetaSequence {
if h == nil {
return nil
}
return &QMetaSequence{h: h,
QMetaContainer: newQMetaContainer(h_QMetaContainer)}
}
QMetaContainer: newQMetaContainer(h_QMetaContainer)}
}
// UnsafeNewQMetaSequence constructs the type using only unsafe pointers.
func UnsafeNewQMetaSequence(h unsafe.Pointer, h_QMetaContainer unsafe.Pointer) *QMetaSequence {
// UnsafeNewQMetaSequence constructs the type using only unsafe pointers.
func UnsafeNewQMetaSequence(h unsafe.Pointer, h_QMetaContainer unsafe.Pointer) *QMetaSequence {
if h == nil {
return nil
}
return &QMetaSequence{h: (*C.QMetaSequence)(h),
QMetaContainer: UnsafeNewQMetaContainer(h_QMetaContainer)}
}
QMetaContainer: UnsafeNewQMetaContainer(h_QMetaContainer)}
}
// NewQMetaSequence constructs a new QMetaSequence object.
func NewQMetaSequence() *QMetaSequence {
// NewQMetaSequence constructs a new QMetaSequence object.
func NewQMetaSequence() *QMetaSequence {
var outptr_QMetaSequence *C.QMetaSequence = nil
var outptr_QMetaContainer *C.QMetaContainer = nil
var outptr_QMetaContainer *C.QMetaContainer = nil
C.QMetaSequence_new(&outptr_QMetaSequence, &outptr_QMetaContainer)
ret := newQMetaSequence(outptr_QMetaSequence, outptr_QMetaContainer)
ret.isSubclass = true
return ret
}
// NewQMetaSequence2 constructs a new QMetaSequence object.
func NewQMetaSequence2(d *QtMetaContainerPrivate__QMetaSequenceInterface) *QMetaSequence {
var outptr_QMetaSequence *C.QMetaSequence = nil
var outptr_QMetaContainer *C.QMetaContainer = nil
C.QMetaSequence_new2(d.cPointer(), &outptr_QMetaSequence, &outptr_QMetaContainer)
ret := newQMetaSequence(outptr_QMetaSequence, outptr_QMetaContainer)
ret.isSubclass = true
return ret
}
func (this *QMetaSequence) ValueMetaType() *QMetaType {
_ret := C.QMetaSequence_ValueMetaType(this.h)
_goptr := newQMetaType(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QMetaSequence) IsSortable() bool {
func (this *QMetaSequence) ValueMetaType() *QMetaType {
_ret := C.QMetaSequence_ValueMetaType(this.h)
_goptr := newQMetaType(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QMetaSequence) IsSortable() bool {
return (bool)(C.QMetaSequence_IsSortable(this.h))
}
func (this *QMetaSequence) CanAddValueAtBegin() bool {
func (this *QMetaSequence) CanAddValueAtBegin() bool {
return (bool)(C.QMetaSequence_CanAddValueAtBegin(this.h))
}
func (this *QMetaSequence) AddValueAtBegin(container unsafe.Pointer, value unsafe.Pointer) {
func (this *QMetaSequence) AddValueAtBegin(container unsafe.Pointer, value unsafe.Pointer) {
C.QMetaSequence_AddValueAtBegin(this.h, container, value)
}
func (this *QMetaSequence) CanAddValueAtEnd() bool {
func (this *QMetaSequence) CanAddValueAtEnd() bool {
return (bool)(C.QMetaSequence_CanAddValueAtEnd(this.h))
}
func (this *QMetaSequence) AddValueAtEnd(container unsafe.Pointer, value unsafe.Pointer) {
func (this *QMetaSequence) AddValueAtEnd(container unsafe.Pointer, value unsafe.Pointer) {
C.QMetaSequence_AddValueAtEnd(this.h, container, value)
}
func (this *QMetaSequence) CanRemoveValueAtBegin() bool {
func (this *QMetaSequence) CanRemoveValueAtBegin() bool {
return (bool)(C.QMetaSequence_CanRemoveValueAtBegin(this.h))
}
func (this *QMetaSequence) RemoveValueAtBegin(container unsafe.Pointer) {
func (this *QMetaSequence) RemoveValueAtBegin(container unsafe.Pointer) {
C.QMetaSequence_RemoveValueAtBegin(this.h, container)
}
func (this *QMetaSequence) CanRemoveValueAtEnd() bool {
func (this *QMetaSequence) CanRemoveValueAtEnd() bool {
return (bool)(C.QMetaSequence_CanRemoveValueAtEnd(this.h))
}
func (this *QMetaSequence) RemoveValueAtEnd(container unsafe.Pointer) {
func (this *QMetaSequence) RemoveValueAtEnd(container unsafe.Pointer) {
C.QMetaSequence_RemoveValueAtEnd(this.h, container)
}
func (this *QMetaSequence) CanGetValueAtIndex() bool {
func (this *QMetaSequence) CanGetValueAtIndex() bool {
return (bool)(C.QMetaSequence_CanGetValueAtIndex(this.h))
}
func (this *QMetaSequence) ValueAtIndex(container unsafe.Pointer, index int64, result unsafe.Pointer) {
func (this *QMetaSequence) ValueAtIndex(container unsafe.Pointer, index int64, result unsafe.Pointer) {
C.QMetaSequence_ValueAtIndex(this.h, container, (C.ptrdiff_t)(index), result)
}
func (this *QMetaSequence) CanSetValueAtIndex() bool {
func (this *QMetaSequence) CanSetValueAtIndex() bool {
return (bool)(C.QMetaSequence_CanSetValueAtIndex(this.h))
}
func (this *QMetaSequence) SetValueAtIndex(container unsafe.Pointer, index int64, value unsafe.Pointer) {
func (this *QMetaSequence) SetValueAtIndex(container unsafe.Pointer, index int64, value unsafe.Pointer) {
C.QMetaSequence_SetValueAtIndex(this.h, container, (C.ptrdiff_t)(index), value)
}
func (this *QMetaSequence) CanAddValue() bool {
func (this *QMetaSequence) CanAddValue() bool {
return (bool)(C.QMetaSequence_CanAddValue(this.h))
}
func (this *QMetaSequence) AddValue(container unsafe.Pointer, value unsafe.Pointer) {
func (this *QMetaSequence) AddValue(container unsafe.Pointer, value unsafe.Pointer) {
C.QMetaSequence_AddValue(this.h, container, value)
}
func (this *QMetaSequence) CanRemoveValue() bool {
func (this *QMetaSequence) CanRemoveValue() bool {
return (bool)(C.QMetaSequence_CanRemoveValue(this.h))
}
func (this *QMetaSequence) RemoveValue(container unsafe.Pointer) {
func (this *QMetaSequence) RemoveValue(container unsafe.Pointer) {
C.QMetaSequence_RemoveValue(this.h, container)
}
func (this *QMetaSequence) CanGetValueAtIterator() bool {
func (this *QMetaSequence) CanGetValueAtIterator() bool {
return (bool)(C.QMetaSequence_CanGetValueAtIterator(this.h))
}
func (this *QMetaSequence) ValueAtIterator(iterator unsafe.Pointer, result unsafe.Pointer) {
func (this *QMetaSequence) ValueAtIterator(iterator unsafe.Pointer, result unsafe.Pointer) {
C.QMetaSequence_ValueAtIterator(this.h, iterator, result)
}
func (this *QMetaSequence) CanSetValueAtIterator() bool {
func (this *QMetaSequence) CanSetValueAtIterator() bool {
return (bool)(C.QMetaSequence_CanSetValueAtIterator(this.h))
}
func (this *QMetaSequence) SetValueAtIterator(iterator unsafe.Pointer, value unsafe.Pointer) {
func (this *QMetaSequence) SetValueAtIterator(iterator unsafe.Pointer, value unsafe.Pointer) {
C.QMetaSequence_SetValueAtIterator(this.h, iterator, value)
}
func (this *QMetaSequence) CanInsertValueAtIterator() bool {
func (this *QMetaSequence) CanInsertValueAtIterator() bool {
return (bool)(C.QMetaSequence_CanInsertValueAtIterator(this.h))
}
func (this *QMetaSequence) InsertValueAtIterator(container unsafe.Pointer, iterator unsafe.Pointer, value unsafe.Pointer) {
func (this *QMetaSequence) InsertValueAtIterator(container unsafe.Pointer, iterator unsafe.Pointer, value unsafe.Pointer) {
C.QMetaSequence_InsertValueAtIterator(this.h, container, iterator, value)
}
func (this *QMetaSequence) CanEraseValueAtIterator() bool {
func (this *QMetaSequence) CanEraseValueAtIterator() bool {
return (bool)(C.QMetaSequence_CanEraseValueAtIterator(this.h))
}
func (this *QMetaSequence) EraseValueAtIterator(container unsafe.Pointer, iterator unsafe.Pointer) {
func (this *QMetaSequence) EraseValueAtIterator(container unsafe.Pointer, iterator unsafe.Pointer) {
C.QMetaSequence_EraseValueAtIterator(this.h, container, iterator)
}
func (this *QMetaSequence) CanEraseRangeAtIterator() bool {
func (this *QMetaSequence) CanEraseRangeAtIterator() bool {
return (bool)(C.QMetaSequence_CanEraseRangeAtIterator(this.h))
}
func (this *QMetaSequence) EraseRangeAtIterator(container unsafe.Pointer, iterator1 unsafe.Pointer, iterator2 unsafe.Pointer) {
func (this *QMetaSequence) EraseRangeAtIterator(container unsafe.Pointer, iterator1 unsafe.Pointer, iterator2 unsafe.Pointer) {
C.QMetaSequence_EraseRangeAtIterator(this.h, container, iterator1, iterator2)
}
func (this *QMetaSequence) CanGetValueAtConstIterator() bool {
func (this *QMetaSequence) CanGetValueAtConstIterator() bool {
return (bool)(C.QMetaSequence_CanGetValueAtConstIterator(this.h))
}
func (this *QMetaSequence) ValueAtConstIterator(iterator unsafe.Pointer, result unsafe.Pointer) {
func (this *QMetaSequence) ValueAtConstIterator(iterator unsafe.Pointer, result unsafe.Pointer) {
C.QMetaSequence_ValueAtConstIterator(this.h, iterator, result)
}
// Delete this object from C++ memory.
func (this *QMetaSequence) Delete() {
// Delete this object from C++ memory.
func (this *QMetaSequence) Delete() {
C.QMetaSequence_Delete(this.h, C.bool(this.isSubclass))
}
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QMetaSequence) GoGC() {
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QMetaSequence) GoGC() {
runtime.SetFinalizer(this, func(this *QMetaSequence) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
}
type QMetaAssociation struct {
type QMetaAssociation struct {
h *C.QMetaAssociation
isSubclass bool
*QMetaContainer
}
}
func (this *QMetaAssociation) cPointer() *C.QMetaAssociation {
func (this *QMetaAssociation) cPointer() *C.QMetaAssociation {
if this == nil {
return nil
}
return this.h
}
}
func (this *QMetaAssociation) UnsafePointer() unsafe.Pointer {
func (this *QMetaAssociation) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
}
// newQMetaAssociation constructs the type using only CGO pointers.
func newQMetaAssociation(h *C.QMetaAssociation, h_QMetaContainer *C.QMetaContainer) *QMetaAssociation {
// newQMetaAssociation constructs the type using only CGO pointers.
func newQMetaAssociation(h *C.QMetaAssociation, h_QMetaContainer *C.QMetaContainer) *QMetaAssociation {
if h == nil {
return nil
}
return &QMetaAssociation{h: h,
QMetaContainer: newQMetaContainer(h_QMetaContainer)}
}
QMetaContainer: newQMetaContainer(h_QMetaContainer)}
}
// UnsafeNewQMetaAssociation constructs the type using only unsafe pointers.
func UnsafeNewQMetaAssociation(h unsafe.Pointer, h_QMetaContainer unsafe.Pointer) *QMetaAssociation {
// UnsafeNewQMetaAssociation constructs the type using only unsafe pointers.
func UnsafeNewQMetaAssociation(h unsafe.Pointer, h_QMetaContainer unsafe.Pointer) *QMetaAssociation {
if h == nil {
return nil
}
return &QMetaAssociation{h: (*C.QMetaAssociation)(h),
QMetaContainer: UnsafeNewQMetaContainer(h_QMetaContainer)}
}
QMetaContainer: UnsafeNewQMetaContainer(h_QMetaContainer)}
}
// NewQMetaAssociation constructs a new QMetaAssociation object.
func NewQMetaAssociation() *QMetaAssociation {
// NewQMetaAssociation constructs a new QMetaAssociation object.
func NewQMetaAssociation() *QMetaAssociation {
var outptr_QMetaAssociation *C.QMetaAssociation = nil
var outptr_QMetaContainer *C.QMetaContainer = nil
var outptr_QMetaContainer *C.QMetaContainer = nil
C.QMetaAssociation_new(&outptr_QMetaAssociation, &outptr_QMetaContainer)
ret := newQMetaAssociation(outptr_QMetaAssociation, outptr_QMetaContainer)
ret.isSubclass = true
return ret
}
}
// NewQMetaAssociation2 constructs a new QMetaAssociation object.
func NewQMetaAssociation2(d *QtMetaContainerPrivate__QMetaAssociationInterface) *QMetaAssociation {
var outptr_QMetaAssociation *C.QMetaAssociation = nil
var outptr_QMetaContainer *C.QMetaContainer = nil
C.QMetaAssociation_new2(d.cPointer(), &outptr_QMetaAssociation, &outptr_QMetaContainer)
ret := newQMetaAssociation(outptr_QMetaAssociation, outptr_QMetaContainer)
ret.isSubclass = true
return ret
}
func (this *QMetaAssociation) KeyMetaType() *QMetaType {
func (this *QMetaAssociation) KeyMetaType() *QMetaType {
_ret := C.QMetaAssociation_KeyMetaType(this.h)
_goptr := newQMetaType(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
_goptr := newQMetaType(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QMetaAssociation) MappedMetaType() *QMetaType {
func (this *QMetaAssociation) MappedMetaType() *QMetaType {
_ret := C.QMetaAssociation_MappedMetaType(this.h)
_goptr := newQMetaType(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
_goptr := newQMetaType(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QMetaAssociation) CanInsertKey() bool {
func (this *QMetaAssociation) CanInsertKey() bool {
return (bool)(C.QMetaAssociation_CanInsertKey(this.h))
}
func (this *QMetaAssociation) InsertKey(container unsafe.Pointer, key unsafe.Pointer) {
func (this *QMetaAssociation) InsertKey(container unsafe.Pointer, key unsafe.Pointer) {
C.QMetaAssociation_InsertKey(this.h, container, key)
}
func (this *QMetaAssociation) CanRemoveKey() bool {
func (this *QMetaAssociation) CanRemoveKey() bool {
return (bool)(C.QMetaAssociation_CanRemoveKey(this.h))
}
func (this *QMetaAssociation) RemoveKey(container unsafe.Pointer, key unsafe.Pointer) {
func (this *QMetaAssociation) RemoveKey(container unsafe.Pointer, key unsafe.Pointer) {
C.QMetaAssociation_RemoveKey(this.h, container, key)
}
func (this *QMetaAssociation) CanContainsKey() bool {
func (this *QMetaAssociation) CanContainsKey() bool {
return (bool)(C.QMetaAssociation_CanContainsKey(this.h))
}
func (this *QMetaAssociation) ContainsKey(container unsafe.Pointer, key unsafe.Pointer) bool {
func (this *QMetaAssociation) ContainsKey(container unsafe.Pointer, key unsafe.Pointer) bool {
return (bool)(C.QMetaAssociation_ContainsKey(this.h, container, key))
}
func (this *QMetaAssociation) CanGetMappedAtKey() bool {
func (this *QMetaAssociation) CanGetMappedAtKey() bool {
return (bool)(C.QMetaAssociation_CanGetMappedAtKey(this.h))
}
func (this *QMetaAssociation) MappedAtKey(container unsafe.Pointer, key unsafe.Pointer, mapped unsafe.Pointer) {
func (this *QMetaAssociation) MappedAtKey(container unsafe.Pointer, key unsafe.Pointer, mapped unsafe.Pointer) {
C.QMetaAssociation_MappedAtKey(this.h, container, key, mapped)
}
func (this *QMetaAssociation) CanSetMappedAtKey() bool {
func (this *QMetaAssociation) CanSetMappedAtKey() bool {
return (bool)(C.QMetaAssociation_CanSetMappedAtKey(this.h))
}
func (this *QMetaAssociation) SetMappedAtKey(container unsafe.Pointer, key unsafe.Pointer, mapped unsafe.Pointer) {
func (this *QMetaAssociation) SetMappedAtKey(container unsafe.Pointer, key unsafe.Pointer, mapped unsafe.Pointer) {
C.QMetaAssociation_SetMappedAtKey(this.h, container, key, mapped)
}
func (this *QMetaAssociation) CanGetKeyAtIterator() bool {
func (this *QMetaAssociation) CanGetKeyAtIterator() bool {
return (bool)(C.QMetaAssociation_CanGetKeyAtIterator(this.h))
}
func (this *QMetaAssociation) KeyAtIterator(iterator unsafe.Pointer, key unsafe.Pointer) {
func (this *QMetaAssociation) KeyAtIterator(iterator unsafe.Pointer, key unsafe.Pointer) {
C.QMetaAssociation_KeyAtIterator(this.h, iterator, key)
}
func (this *QMetaAssociation) CanGetKeyAtConstIterator() bool {
func (this *QMetaAssociation) CanGetKeyAtConstIterator() bool {
return (bool)(C.QMetaAssociation_CanGetKeyAtConstIterator(this.h))
}
func (this *QMetaAssociation) KeyAtConstIterator(iterator unsafe.Pointer, key unsafe.Pointer) {
func (this *QMetaAssociation) KeyAtConstIterator(iterator unsafe.Pointer, key unsafe.Pointer) {
C.QMetaAssociation_KeyAtConstIterator(this.h, iterator, key)
}
func (this *QMetaAssociation) CanGetMappedAtIterator() bool {
func (this *QMetaAssociation) CanGetMappedAtIterator() bool {
return (bool)(C.QMetaAssociation_CanGetMappedAtIterator(this.h))
}
func (this *QMetaAssociation) MappedAtIterator(iterator unsafe.Pointer, mapped unsafe.Pointer) {
func (this *QMetaAssociation) MappedAtIterator(iterator unsafe.Pointer, mapped unsafe.Pointer) {
C.QMetaAssociation_MappedAtIterator(this.h, iterator, mapped)
}
func (this *QMetaAssociation) CanGetMappedAtConstIterator() bool {
func (this *QMetaAssociation) CanGetMappedAtConstIterator() bool {
return (bool)(C.QMetaAssociation_CanGetMappedAtConstIterator(this.h))
}
func (this *QMetaAssociation) MappedAtConstIterator(iterator unsafe.Pointer, mapped unsafe.Pointer) {
func (this *QMetaAssociation) MappedAtConstIterator(iterator unsafe.Pointer, mapped unsafe.Pointer) {
C.QMetaAssociation_MappedAtConstIterator(this.h, iterator, mapped)
}
func (this *QMetaAssociation) CanSetMappedAtIterator() bool {
func (this *QMetaAssociation) CanSetMappedAtIterator() bool {
return (bool)(C.QMetaAssociation_CanSetMappedAtIterator(this.h))
}
func (this *QMetaAssociation) SetMappedAtIterator(iterator unsafe.Pointer, mapped unsafe.Pointer) {
func (this *QMetaAssociation) SetMappedAtIterator(iterator unsafe.Pointer, mapped unsafe.Pointer) {
C.QMetaAssociation_SetMappedAtIterator(this.h, iterator, mapped)
}
func (this *QMetaAssociation) CanCreateIteratorAtKey() bool {
func (this *QMetaAssociation) CanCreateIteratorAtKey() bool {
return (bool)(C.QMetaAssociation_CanCreateIteratorAtKey(this.h))
}
func (this *QMetaAssociation) CreateIteratorAtKey(container unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer {
func (this *QMetaAssociation) CreateIteratorAtKey(container unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer {
return (unsafe.Pointer)(C.QMetaAssociation_CreateIteratorAtKey(this.h, container, key))
}
func (this *QMetaAssociation) CanCreateConstIteratorAtKey() bool {
func (this *QMetaAssociation) CanCreateConstIteratorAtKey() bool {
return (bool)(C.QMetaAssociation_CanCreateConstIteratorAtKey(this.h))
}
func (this *QMetaAssociation) CreateConstIteratorAtKey(container unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer {
func (this *QMetaAssociation) CreateConstIteratorAtKey(container unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer {
return (unsafe.Pointer)(C.QMetaAssociation_CreateConstIteratorAtKey(this.h, container, key))
}
// Delete this object from C++ memory.
func (this *QMetaAssociation) Delete() {
// Delete this object from C++ memory.
func (this *QMetaAssociation) Delete() {
C.QMetaAssociation_Delete(this.h, C.bool(this.isSubclass))
}
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QMetaAssociation) GoGC() {
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QMetaAssociation) GoGC() {
runtime.SetFinalizer(this, func(this *QMetaAssociation) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
}

32
qt6/gen_qmetacontainer.h
View File

@ -19,43 +19,15 @@ class QMetaAssociation;
class QMetaContainer;
class QMetaSequence;
class QMetaType;
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtMetaContainerPrivate__QMetaAssociationInterface)
typedef QtMetaContainerPrivate::QMetaAssociationInterface QtMetaContainerPrivate__QMetaAssociationInterface;
#else
class QtMetaContainerPrivate__QMetaAssociationInterface;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtMetaContainerPrivate__QMetaContainerInterface)
typedef QtMetaContainerPrivate::QMetaContainerInterface QtMetaContainerPrivate__QMetaContainerInterface;
#else
class QtMetaContainerPrivate__QMetaContainerInterface;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtMetaContainerPrivate__QMetaSequenceInterface)
typedef QtMetaContainerPrivate::QMetaSequenceInterface QtMetaContainerPrivate__QMetaSequenceInterface;
#else
class QtMetaContainerPrivate__QMetaSequenceInterface;
#endif
#else
typedef struct QMetaAssociation QMetaAssociation;
typedef struct QMetaContainer QMetaContainer;
typedef struct QMetaSequence QMetaSequence;
typedef struct QMetaType QMetaType;
typedef struct QtMetaContainerPrivate__QMetaAssociationInterface QtMetaContainerPrivate__QMetaAssociationInterface;
typedef struct QtMetaContainerPrivate__QMetaContainerInterface QtMetaContainerPrivate__QMetaContainerInterface;
typedef struct QtMetaContainerPrivate__QMetaSequenceInterface QtMetaContainerPrivate__QMetaSequenceInterface;
#endif
void QtMetaContainerPrivate__QMetaContainerInterface_new(QtMetaContainerPrivate__QMetaContainerInterface** outptr_QtMetaContainerPrivate__QMetaContainerInterface);
void QtMetaContainerPrivate__QMetaContainerInterface_Delete(QtMetaContainerPrivate__QMetaContainerInterface* self, bool isSubclass);
void QtMetaContainerPrivate__QMetaSequenceInterface_new(QtMetaContainerPrivate__QMetaSequenceInterface** outptr_QtMetaContainerPrivate__QMetaSequenceInterface, QtMetaContainerPrivate__QMetaContainerInterface** outptr_QtMetaContainerPrivate__QMetaContainerInterface);
void QtMetaContainerPrivate__QMetaSequenceInterface_Delete(QtMetaContainerPrivate__QMetaSequenceInterface* self, bool isSubclass);
void QtMetaContainerPrivate__QMetaAssociationInterface_new(QtMetaContainerPrivate__QMetaAssociationInterface** outptr_QtMetaContainerPrivate__QMetaAssociationInterface, QtMetaContainerPrivate__QMetaContainerInterface** outptr_QtMetaContainerPrivate__QMetaContainerInterface);
void QtMetaContainerPrivate__QMetaAssociationInterface_Delete(QtMetaContainerPrivate__QMetaAssociationInterface* self, bool isSubclass);
void QMetaContainer_new(QMetaContainer** outptr_QMetaContainer);
void QMetaContainer_new2(QtMetaContainerPrivate__QMetaContainerInterface* d, QMetaContainer** outptr_QMetaContainer);
void QMetaContainer_new3(QMetaContainer* param1, QMetaContainer** outptr_QMetaContainer);
void QMetaContainer_new2(QMetaContainer* param1, QMetaContainer** outptr_QMetaContainer);
bool QMetaContainer_HasInputIterator(const QMetaContainer* self);
bool QMetaContainer_HasForwardIterator(const QMetaContainer* self);
bool QMetaContainer_HasBidirectionalIterator(const QMetaContainer* self);
@ -83,7 +55,6 @@ ptrdiff_t QMetaContainer_DiffConstIterator(const QMetaContainer* self, const voi
void QMetaContainer_Delete(QMetaContainer* self, bool isSubclass);
void QMetaSequence_new(QMetaSequence** outptr_QMetaSequence, QMetaContainer** outptr_QMetaContainer);
void QMetaSequence_new2(QtMetaContainerPrivate__QMetaSequenceInterface* d, QMetaSequence** outptr_QMetaSequence, QMetaContainer** outptr_QMetaContainer);
QMetaType* QMetaSequence_ValueMetaType(const QMetaSequence* self);
bool QMetaSequence_IsSortable(const QMetaSequence* self);
bool QMetaSequence_CanAddValueAtBegin(const QMetaSequence* self);
@ -117,7 +88,6 @@ void QMetaSequence_ValueAtConstIterator(const QMetaSequence* self, const void* i
void QMetaSequence_Delete(QMetaSequence* self, bool isSubclass);
void QMetaAssociation_new(QMetaAssociation** outptr_QMetaAssociation, QMetaContainer** outptr_QMetaContainer);
void QMetaAssociation_new2(QtMetaContainerPrivate__QMetaAssociationInterface* d, QMetaAssociation** outptr_QMetaAssociation, QMetaContainer** outptr_QMetaContainer);
QMetaType* QMetaAssociation_KeyMetaType(const QMetaAssociation* self);
QMetaType* QMetaAssociation_MappedMetaType(const QMetaAssociation* self);
bool QMetaAssociation_CanInsertKey(const QMetaAssociation* self);

57
qt6/gen_qmetatype.cpp
View File

@ -5,21 +5,10 @@
#include <QMetaObject>
#include <QMetaType>
#include <QPartialOrdering>
#define WORKAROUND_INNER_CLASS_DEFINITION_QtMetaTypePrivate__QPairVariantInterfaceImpl
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QMetaTypeInterface
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QTypeNormalizer
#include <qmetatype.h>
#include "gen_qmetatype.h"
#include "_cgo_export.h"
void QtPrivate__QMetaTypeInterface_Delete(QtPrivate__QMetaTypeInterface* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QMetaTypeInterface*>( self );
} else {
delete self;
}
}
void QMetaType_new(int typeVal, QMetaType** outptr_QMetaType) {
QMetaType* ret = new QMetaType(static_cast<int>(typeVal));
*outptr_QMetaType = ret;
@ -265,49 +254,3 @@ void QMetaType_Delete(QMetaType* self, bool isSubclass) {
}
}
void QtMetaTypePrivate__QPairVariantInterfaceImpl_new(QtMetaTypePrivate__QPairVariantInterfaceImpl** outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl) {
QtMetaTypePrivate::QPairVariantInterfaceImpl* ret = new QtMetaTypePrivate::QPairVariantInterfaceImpl();
*outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl = ret;
}
void QtMetaTypePrivate__QPairVariantInterfaceImpl_new2(QtMetaTypePrivate__QPairVariantInterfaceImpl* param1, QtMetaTypePrivate__QPairVariantInterfaceImpl** outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl) {
QtMetaTypePrivate::QPairVariantInterfaceImpl* ret = new QtMetaTypePrivate::QPairVariantInterfaceImpl(*param1);
*outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl = ret;
}
void QtMetaTypePrivate__QPairVariantInterfaceImpl_First(const QtMetaTypePrivate__QPairVariantInterfaceImpl* self, void* dataPtr) {
self->first(dataPtr);
}
void QtMetaTypePrivate__QPairVariantInterfaceImpl_Second(const QtMetaTypePrivate__QPairVariantInterfaceImpl* self, void* dataPtr) {
self->second(dataPtr);
}
void QtMetaTypePrivate__QPairVariantInterfaceImpl_Delete(QtMetaTypePrivate__QPairVariantInterfaceImpl* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtMetaTypePrivate::QPairVariantInterfaceImpl*>( self );
} else {
delete self;
}
}
int QtPrivate__QTypeNormalizer_NormalizeTypeFromSignature(QtPrivate__QTypeNormalizer* self, const char* begin, const char* end) {
return self->normalizeTypeFromSignature(begin, end);
}
int QtPrivate__QTypeNormalizer_NormalizeType(QtPrivate__QTypeNormalizer* self, const char* begin, const char* end) {
return self->normalizeType(begin, end);
}
int QtPrivate__QTypeNormalizer_NormalizeType3(QtPrivate__QTypeNormalizer* self, const char* begin, const char* end, bool adjustConst) {
return self->normalizeType(begin, end, adjustConst);
}
void QtPrivate__QTypeNormalizer_Delete(QtPrivate__QTypeNormalizer* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QTypeNormalizer*>( self );
} else {
delete self;
}
}

202
qt6/gen_qmetatype.go
View File

@ -131,56 +131,6 @@ const (
QMetaType__IsConst QMetaType__TypeFlag = 8192
)
type QtPrivate__QMetaTypeInterface struct {
h *C.QtPrivate__QMetaTypeInterface
isSubclass bool
}
func (this *QtPrivate__QMetaTypeInterface) cPointer() *C.QtPrivate__QMetaTypeInterface {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QMetaTypeInterface) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QMetaTypeInterface constructs the type using only CGO pointers.
func newQtPrivate__QMetaTypeInterface(h *C.QtPrivate__QMetaTypeInterface) *QtPrivate__QMetaTypeInterface {
if h == nil {
return nil
}
return &QtPrivate__QMetaTypeInterface{h: h}
}
// UnsafeNewQtPrivate__QMetaTypeInterface constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QMetaTypeInterface(h unsafe.Pointer) *QtPrivate__QMetaTypeInterface {
if h == nil {
return nil
}
return &QtPrivate__QMetaTypeInterface{h: (*C.QtPrivate__QMetaTypeInterface)(h)}
}
// Delete this object from C++ memory.
func (this *QtPrivate__QMetaTypeInterface) Delete() {
C.QtPrivate__QMetaTypeInterface_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QMetaTypeInterface) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QMetaTypeInterface) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QMetaType struct {
h *C.QMetaType
isSubclass bool
@ -492,155 +442,3 @@ func (this *QMetaType) GoGC() {
runtime.KeepAlive(this.h)
})
}
type QtMetaTypePrivate__QPairVariantInterfaceImpl struct {
h *C.QtMetaTypePrivate__QPairVariantInterfaceImpl
isSubclass bool
}
func (this *QtMetaTypePrivate__QPairVariantInterfaceImpl) cPointer() *C.QtMetaTypePrivate__QPairVariantInterfaceImpl {
if this == nil {
return nil
}
return this.h
}
func (this *QtMetaTypePrivate__QPairVariantInterfaceImpl) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtMetaTypePrivate__QPairVariantInterfaceImpl constructs the type using only CGO pointers.
func newQtMetaTypePrivate__QPairVariantInterfaceImpl(h *C.QtMetaTypePrivate__QPairVariantInterfaceImpl) *QtMetaTypePrivate__QPairVariantInterfaceImpl {
if h == nil {
return nil
}
return &QtMetaTypePrivate__QPairVariantInterfaceImpl{h: h}
}
// UnsafeNewQtMetaTypePrivate__QPairVariantInterfaceImpl constructs the type using only unsafe pointers.
func UnsafeNewQtMetaTypePrivate__QPairVariantInterfaceImpl(h unsafe.Pointer) *QtMetaTypePrivate__QPairVariantInterfaceImpl {
if h == nil {
return nil
}
return &QtMetaTypePrivate__QPairVariantInterfaceImpl{h: (*C.QtMetaTypePrivate__QPairVariantInterfaceImpl)(h)}
}
// NewQtMetaTypePrivate__QPairVariantInterfaceImpl constructs a new QtMetaTypePrivate::QPairVariantInterfaceImpl object.
func NewQtMetaTypePrivate__QPairVariantInterfaceImpl() *QtMetaTypePrivate__QPairVariantInterfaceImpl {
var outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl *C.QtMetaTypePrivate__QPairVariantInterfaceImpl = nil
C.QtMetaTypePrivate__QPairVariantInterfaceImpl_new(&outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl)
ret := newQtMetaTypePrivate__QPairVariantInterfaceImpl(outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl)
ret.isSubclass = true
return ret
}
// NewQtMetaTypePrivate__QPairVariantInterfaceImpl2 constructs a new QtMetaTypePrivate::QPairVariantInterfaceImpl object.
func NewQtMetaTypePrivate__QPairVariantInterfaceImpl2(param1 *QtMetaTypePrivate__QPairVariantInterfaceImpl) *QtMetaTypePrivate__QPairVariantInterfaceImpl {
var outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl *C.QtMetaTypePrivate__QPairVariantInterfaceImpl = nil
C.QtMetaTypePrivate__QPairVariantInterfaceImpl_new2(param1.cPointer(), &outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl)
ret := newQtMetaTypePrivate__QPairVariantInterfaceImpl(outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl)
ret.isSubclass = true
return ret
}
func (this *QtMetaTypePrivate__QPairVariantInterfaceImpl) First(dataPtr unsafe.Pointer) {
C.QtMetaTypePrivate__QPairVariantInterfaceImpl_First(this.h, dataPtr)
}
func (this *QtMetaTypePrivate__QPairVariantInterfaceImpl) Second(dataPtr unsafe.Pointer) {
C.QtMetaTypePrivate__QPairVariantInterfaceImpl_Second(this.h, dataPtr)
}
// Delete this object from C++ memory.
func (this *QtMetaTypePrivate__QPairVariantInterfaceImpl) Delete() {
C.QtMetaTypePrivate__QPairVariantInterfaceImpl_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtMetaTypePrivate__QPairVariantInterfaceImpl) GoGC() {
runtime.SetFinalizer(this, func(this *QtMetaTypePrivate__QPairVariantInterfaceImpl) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__QTypeNormalizer struct {
h *C.QtPrivate__QTypeNormalizer
isSubclass bool
}
func (this *QtPrivate__QTypeNormalizer) cPointer() *C.QtPrivate__QTypeNormalizer {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QTypeNormalizer) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QTypeNormalizer constructs the type using only CGO pointers.
func newQtPrivate__QTypeNormalizer(h *C.QtPrivate__QTypeNormalizer) *QtPrivate__QTypeNormalizer {
if h == nil {
return nil
}
return &QtPrivate__QTypeNormalizer{h: h}
}
// UnsafeNewQtPrivate__QTypeNormalizer constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QTypeNormalizer(h unsafe.Pointer) *QtPrivate__QTypeNormalizer {
if h == nil {
return nil
}
return &QtPrivate__QTypeNormalizer{h: (*C.QtPrivate__QTypeNormalizer)(h)}
}
func (this *QtPrivate__QTypeNormalizer) NormalizeTypeFromSignature(begin string, end string) int {
begin_Cstring := C.CString(begin)
defer C.free(unsafe.Pointer(begin_Cstring))
end_Cstring := C.CString(end)
defer C.free(unsafe.Pointer(end_Cstring))
return (int)(C.QtPrivate__QTypeNormalizer_NormalizeTypeFromSignature(this.h, begin_Cstring, end_Cstring))
}
func (this *QtPrivate__QTypeNormalizer) NormalizeType(begin string, end string) int {
begin_Cstring := C.CString(begin)
defer C.free(unsafe.Pointer(begin_Cstring))
end_Cstring := C.CString(end)
defer C.free(unsafe.Pointer(end_Cstring))
return (int)(C.QtPrivate__QTypeNormalizer_NormalizeType(this.h, begin_Cstring, end_Cstring))
}
func (this *QtPrivate__QTypeNormalizer) NormalizeType3(begin string, end string, adjustConst bool) int {
begin_Cstring := C.CString(begin)
defer C.free(unsafe.Pointer(begin_Cstring))
end_Cstring := C.CString(end)
defer C.free(unsafe.Pointer(end_Cstring))
return (int)(C.QtPrivate__QTypeNormalizer_NormalizeType3(this.h, begin_Cstring, end_Cstring, (C.bool)(adjustConst)))
}
// Delete this object from C++ memory.
func (this *QtPrivate__QTypeNormalizer) Delete() {
C.QtPrivate__QTypeNormalizer_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QTypeNormalizer) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QTypeNormalizer) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

31
qt6/gen_qmetatype.h
View File

@ -22,21 +22,6 @@ class QDebug;
class QMetaObject;
class QMetaType;
class QPartialOrdering;
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtMetaTypePrivate__QPairVariantInterfaceImpl)
typedef QtMetaTypePrivate::QPairVariantInterfaceImpl QtMetaTypePrivate__QPairVariantInterfaceImpl;
#else
class QtMetaTypePrivate__QPairVariantInterfaceImpl;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QMetaTypeInterface)
typedef QtPrivate::QMetaTypeInterface QtPrivate__QMetaTypeInterface;
#else
class QtPrivate__QMetaTypeInterface;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QTypeNormalizer)
typedef QtPrivate::QTypeNormalizer QtPrivate__QTypeNormalizer;
#else
class QtPrivate__QTypeNormalizer;
#endif
#else
typedef struct QByteArray QByteArray;
typedef struct QByteArrayView QByteArrayView;
@ -45,13 +30,8 @@ typedef struct QDebug QDebug;
typedef struct QMetaObject QMetaObject;
typedef struct QMetaType QMetaType;
typedef struct QPartialOrdering QPartialOrdering;
typedef struct QtMetaTypePrivate__QPairVariantInterfaceImpl QtMetaTypePrivate__QPairVariantInterfaceImpl;
typedef struct QtPrivate__QMetaTypeInterface QtPrivate__QMetaTypeInterface;
typedef struct QtPrivate__QTypeNormalizer QtPrivate__QTypeNormalizer;
#endif
void QtPrivate__QMetaTypeInterface_Delete(QtPrivate__QMetaTypeInterface* self, bool isSubclass);
void QMetaType_new(int typeVal, QMetaType** outptr_QMetaType);
void QMetaType_new2(QMetaType** outptr_QMetaType);
void QMetaType_new3(QMetaType* param1, QMetaType** outptr_QMetaType);
@ -111,17 +91,6 @@ void* QMetaType_Create1(const QMetaType* self, const void* copyVal);
void* QMetaType_Construct2(const QMetaType* self, void* where, const void* copyVal);
void QMetaType_Delete(QMetaType* self, bool isSubclass);
void QtMetaTypePrivate__QPairVariantInterfaceImpl_new(QtMetaTypePrivate__QPairVariantInterfaceImpl** outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl);
void QtMetaTypePrivate__QPairVariantInterfaceImpl_new2(QtMetaTypePrivate__QPairVariantInterfaceImpl* param1, QtMetaTypePrivate__QPairVariantInterfaceImpl** outptr_QtMetaTypePrivate__QPairVariantInterfaceImpl);
void QtMetaTypePrivate__QPairVariantInterfaceImpl_First(const QtMetaTypePrivate__QPairVariantInterfaceImpl* self, void* dataPtr);
void QtMetaTypePrivate__QPairVariantInterfaceImpl_Second(const QtMetaTypePrivate__QPairVariantInterfaceImpl* self, void* dataPtr);
void QtMetaTypePrivate__QPairVariantInterfaceImpl_Delete(QtMetaTypePrivate__QPairVariantInterfaceImpl* self, bool isSubclass);
int QtPrivate__QTypeNormalizer_NormalizeTypeFromSignature(QtPrivate__QTypeNormalizer* self, const char* begin, const char* end);
int QtPrivate__QTypeNormalizer_NormalizeType(QtPrivate__QTypeNormalizer* self, const char* begin, const char* end);
int QtPrivate__QTypeNormalizer_NormalizeType3(QtPrivate__QTypeNormalizer* self, const char* begin, const char* end, bool adjustConst);
void QtPrivate__QTypeNormalizer_Delete(QtPrivate__QTypeNormalizer* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif

4
qt6/gen_qnamespace.cpp
View File

@ -5,12 +5,12 @@
#include "gen_qnamespace.h"
#include "_cgo_export.h"
void Disambiguated_t_new(Disambiguated_t** outptr_Qt__Disambiguated_t) {
void Disambiguated_t_new(Disambiguated_t** outptr_Disambiguated_t) {
Qt::Disambiguated_t* ret = new Qt::Disambiguated_t();
*outptr_Disambiguated_t = ret;
}
void Disambiguated_t_new2(Disambiguated_t* param1, Disambiguated_t** outptr_Qt__Disambiguated_t) {
void Disambiguated_t_new2(Disambiguated_t* param1, Disambiguated_t** outptr_Disambiguated_t) {
Qt::Disambiguated_t* ret = new Qt::Disambiguated_t(*param1);
*outptr_Disambiguated_t = ret;
}

4
qt6/gen_qnamespace.h
View File

@ -28,8 +28,8 @@ typedef struct QKeyCombination QKeyCombination;
typedef struct Disambiguated_t Disambiguated_t;
#endif
void Disambiguated_t_new(Disambiguated_t** outptr_Qt__Disambiguated_t);
void Disambiguated_t_new2(Disambiguated_t* param1, Disambiguated_t** outptr_Qt__Disambiguated_t);
void Disambiguated_t_new(Disambiguated_t** outptr_Disambiguated_t);
void Disambiguated_t_new2(Disambiguated_t* param1, Disambiguated_t** outptr_Disambiguated_t);
void Disambiguated_t_Delete(Disambiguated_t* self, bool isSubclass);
void QInternal_Delete(QInternal* self, bool isSubclass);

2
qt6/gen_qprogressbar.cpp
View File

@ -872,7 +872,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QProgressBar_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

9
qt6/gen_qproperty.cpp
View File

@ -9,7 +9,6 @@
#include <cstring>
#include <QUntypedBindable>
#include <QUntypedPropertyBinding>
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QBindableInterface
#include <qproperty.h>
#include "gen_qproperty.h"
#include "_cgo_export.h"
@ -166,14 +165,6 @@ void QPropertyNotifier_Delete(QPropertyNotifier* self, bool isSubclass) {
}
}
void QtPrivate__QBindableInterface_Delete(QtPrivate__QBindableInterface* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QBindableInterface*>( self );
} else {
delete self;
}
}
void QUntypedBindable_new(QUntypedBindable** outptr_QUntypedBindable) {
QUntypedBindable* ret = new QUntypedBindable();
*outptr_QUntypedBindable = ret;

50
qt6/gen_qproperty.go
View File

@ -513,56 +513,6 @@ func (this *QPropertyNotifier) GoGC() {
})
}
type QtPrivate__QBindableInterface struct {
h *C.QtPrivate__QBindableInterface
isSubclass bool
}
func (this *QtPrivate__QBindableInterface) cPointer() *C.QtPrivate__QBindableInterface {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QBindableInterface) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QBindableInterface constructs the type using only CGO pointers.
func newQtPrivate__QBindableInterface(h *C.QtPrivate__QBindableInterface) *QtPrivate__QBindableInterface {
if h == nil {
return nil
}
return &QtPrivate__QBindableInterface{h: h}
}
// UnsafeNewQtPrivate__QBindableInterface constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QBindableInterface(h unsafe.Pointer) *QtPrivate__QBindableInterface {
if h == nil {
return nil
}
return &QtPrivate__QBindableInterface{h: (*C.QtPrivate__QBindableInterface)(h)}
}
// Delete this object from C++ memory.
func (this *QtPrivate__QBindableInterface) Delete() {
C.QtPrivate__QBindableInterface_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QBindableInterface) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QBindableInterface) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QUntypedBindable struct {
h *C.QUntypedBindable
isSubclass bool

8
qt6/gen_qproperty.h
View File

@ -23,11 +23,6 @@ class QPropertyObserver;
class QPropertyObserverBase;
class QUntypedBindable;
class QUntypedPropertyBinding;
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QBindableInterface)
typedef QtPrivate::QBindableInterface QtPrivate__QBindableInterface;
#else
class QtPrivate__QBindableInterface;
#endif
#else
typedef struct QMetaType QMetaType;
typedef struct QPropertyBindingError QPropertyBindingError;
@ -37,7 +32,6 @@ typedef struct QPropertyObserver QPropertyObserver;
typedef struct QPropertyObserverBase QPropertyObserverBase;
typedef struct QUntypedBindable QUntypedBindable;
typedef struct QUntypedPropertyBinding QUntypedPropertyBinding;
typedef struct QtPrivate__QBindableInterface QtPrivate__QBindableInterface;
#endif
void QPropertyBindingSourceLocation_new(QPropertyBindingSourceLocation** outptr_QPropertyBindingSourceLocation);
@ -72,8 +66,6 @@ void QPropertyObserver_Delete(QPropertyObserver* self, bool isSubclass);
void QPropertyNotifier_new(QPropertyNotifier** outptr_QPropertyNotifier, QPropertyObserver** outptr_QPropertyObserver, QPropertyObserverBase** outptr_QPropertyObserverBase);
void QPropertyNotifier_Delete(QPropertyNotifier* self, bool isSubclass);
void QtPrivate__QBindableInterface_Delete(QtPrivate__QBindableInterface* self, bool isSubclass);
void QUntypedBindable_new(QUntypedBindable** outptr_QUntypedBindable);
void QUntypedBindable_new2(QUntypedBindable* param1, QUntypedBindable** outptr_QUntypedBindable);
bool QUntypedBindable_IsValid(const QUntypedBindable* self);

92
qt6/gen_qpropertyprivate.cpp
View File

@ -1,32 +1,9 @@
#include <QBindingStorage>
#include <QPropertyProxyBindingData>
#include <QUntypedPropertyBinding>
#include <QUntypedPropertyData>
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__BindingFunctionVTable
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__MSVCWorkAround
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QPropertyBindingData
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QPropertyBindingFunction
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__RefCounted
#include <qpropertyprivate.h>
#include "gen_qpropertyprivate.h"
#include "_cgo_export.h"
void QtPrivate__RefCounted_AddRef(QtPrivate__RefCounted* self) {
self->addRef();
}
bool QtPrivate__RefCounted_Deref(QtPrivate__RefCounted* self) {
return self->deref();
}
void QtPrivate__RefCounted_Delete(QtPrivate__RefCounted* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::RefCounted*>( self );
} else {
delete self;
}
}
void QUntypedPropertyData_Delete(QUntypedPropertyData* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QUntypedPropertyData*>( self );
@ -43,72 +20,3 @@ void QPropertyProxyBindingData_Delete(QPropertyProxyBindingData* self, bool isSu
}
}
void QtPrivate__MSVCWorkAround_Delete(QtPrivate__MSVCWorkAround* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::MSVCWorkAround*>( self );
} else {
delete self;
}
}
void QtPrivate__BindingFunctionVTable_Delete(QtPrivate__BindingFunctionVTable* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::BindingFunctionVTable*>( self );
} else {
delete self;
}
}
void QtPrivate__QPropertyBindingFunction_Delete(QtPrivate__QPropertyBindingFunction* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QPropertyBindingFunction*>( self );
} else {
delete self;
}
}
void QtPrivate__QPropertyBindingData_new(QtPrivate__QPropertyBindingData** outptr_QtPrivate__QPropertyBindingData) {
QtPrivate::QPropertyBindingData* ret = new QtPrivate::QPropertyBindingData();
*outptr_QtPrivate__QPropertyBindingData = ret;
}
bool QtPrivate__QPropertyBindingData_HasBinding(const QtPrivate__QPropertyBindingData* self) {
return self->hasBinding();
}
bool QtPrivate__QPropertyBindingData_IsNotificationDelayed(const QtPrivate__QPropertyBindingData* self) {
return self->isNotificationDelayed();
}
QUntypedPropertyBinding* QtPrivate__QPropertyBindingData_SetBinding(QtPrivate__QPropertyBindingData* self, QUntypedPropertyBinding* newBinding, QUntypedPropertyData* propertyDataPtr) {
return new QUntypedPropertyBinding(self->setBinding(*newBinding, propertyDataPtr));
}
void QtPrivate__QPropertyBindingData_EvaluateIfDirty(const QtPrivate__QPropertyBindingData* self, QUntypedPropertyData* param1) {
self->evaluateIfDirty(param1);
}
void QtPrivate__QPropertyBindingData_RemoveBinding(QtPrivate__QPropertyBindingData* self) {
self->removeBinding();
}
void QtPrivate__QPropertyBindingData_RegisterWithCurrentlyEvaluatingBinding2(const QtPrivate__QPropertyBindingData* self) {
self->registerWithCurrentlyEvaluatingBinding();
}
void QtPrivate__QPropertyBindingData_NotifyObservers(const QtPrivate__QPropertyBindingData* self, QUntypedPropertyData* propertyDataPtr) {
self->notifyObservers(propertyDataPtr);
}
void QtPrivate__QPropertyBindingData_NotifyObservers2(const QtPrivate__QPropertyBindingData* self, QUntypedPropertyData* propertyDataPtr, QBindingStorage* storage) {
self->notifyObservers(propertyDataPtr, storage);
}
void QtPrivate__QPropertyBindingData_Delete(QtPrivate__QPropertyBindingData* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QPropertyBindingData*>( self );
} else {
delete self;
}
}

303
qt6/gen_qpropertyprivate.go
View File

@ -13,64 +13,6 @@ import (
"unsafe"
)
type QtPrivate__RefCounted struct {
h *C.QtPrivate__RefCounted
isSubclass bool
}
func (this *QtPrivate__RefCounted) cPointer() *C.QtPrivate__RefCounted {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__RefCounted) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__RefCounted constructs the type using only CGO pointers.
func newQtPrivate__RefCounted(h *C.QtPrivate__RefCounted) *QtPrivate__RefCounted {
if h == nil {
return nil
}
return &QtPrivate__RefCounted{h: h}
}
// UnsafeNewQtPrivate__RefCounted constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__RefCounted(h unsafe.Pointer) *QtPrivate__RefCounted {
if h == nil {
return nil
}
return &QtPrivate__RefCounted{h: (*C.QtPrivate__RefCounted)(h)}
}
func (this *QtPrivate__RefCounted) AddRef() {
C.QtPrivate__RefCounted_AddRef(this.h)
}
func (this *QtPrivate__RefCounted) Deref() bool {
return (bool)(C.QtPrivate__RefCounted_Deref(this.h))
}
// Delete this object from C++ memory.
func (this *QtPrivate__RefCounted) Delete() {
C.QtPrivate__RefCounted_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__RefCounted) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__RefCounted) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QUntypedPropertyData struct {
h *C.QUntypedPropertyData
isSubclass bool
@ -170,248 +112,3 @@ func (this *QPropertyProxyBindingData) GoGC() {
runtime.KeepAlive(this.h)
})
}
type QtPrivate__MSVCWorkAround struct {
h *C.QtPrivate__MSVCWorkAround
isSubclass bool
}
func (this *QtPrivate__MSVCWorkAround) cPointer() *C.QtPrivate__MSVCWorkAround {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__MSVCWorkAround) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__MSVCWorkAround constructs the type using only CGO pointers.
func newQtPrivate__MSVCWorkAround(h *C.QtPrivate__MSVCWorkAround) *QtPrivate__MSVCWorkAround {
if h == nil {
return nil
}
return &QtPrivate__MSVCWorkAround{h: h}
}
// UnsafeNewQtPrivate__MSVCWorkAround constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__MSVCWorkAround(h unsafe.Pointer) *QtPrivate__MSVCWorkAround {
if h == nil {
return nil
}
return &QtPrivate__MSVCWorkAround{h: (*C.QtPrivate__MSVCWorkAround)(h)}
}
// Delete this object from C++ memory.
func (this *QtPrivate__MSVCWorkAround) Delete() {
C.QtPrivate__MSVCWorkAround_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__MSVCWorkAround) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__MSVCWorkAround) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__BindingFunctionVTable struct {
h *C.QtPrivate__BindingFunctionVTable
isSubclass bool
}
func (this *QtPrivate__BindingFunctionVTable) cPointer() *C.QtPrivate__BindingFunctionVTable {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__BindingFunctionVTable) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__BindingFunctionVTable constructs the type using only CGO pointers.
func newQtPrivate__BindingFunctionVTable(h *C.QtPrivate__BindingFunctionVTable) *QtPrivate__BindingFunctionVTable {
if h == nil {
return nil
}
return &QtPrivate__BindingFunctionVTable{h: h}
}
// UnsafeNewQtPrivate__BindingFunctionVTable constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__BindingFunctionVTable(h unsafe.Pointer) *QtPrivate__BindingFunctionVTable {
if h == nil {
return nil
}
return &QtPrivate__BindingFunctionVTable{h: (*C.QtPrivate__BindingFunctionVTable)(h)}
}
// Delete this object from C++ memory.
func (this *QtPrivate__BindingFunctionVTable) Delete() {
C.QtPrivate__BindingFunctionVTable_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__BindingFunctionVTable) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__BindingFunctionVTable) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__QPropertyBindingFunction struct {
h *C.QtPrivate__QPropertyBindingFunction
isSubclass bool
}
func (this *QtPrivate__QPropertyBindingFunction) cPointer() *C.QtPrivate__QPropertyBindingFunction {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QPropertyBindingFunction) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QPropertyBindingFunction constructs the type using only CGO pointers.
func newQtPrivate__QPropertyBindingFunction(h *C.QtPrivate__QPropertyBindingFunction) *QtPrivate__QPropertyBindingFunction {
if h == nil {
return nil
}
return &QtPrivate__QPropertyBindingFunction{h: h}
}
// UnsafeNewQtPrivate__QPropertyBindingFunction constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QPropertyBindingFunction(h unsafe.Pointer) *QtPrivate__QPropertyBindingFunction {
if h == nil {
return nil
}
return &QtPrivate__QPropertyBindingFunction{h: (*C.QtPrivate__QPropertyBindingFunction)(h)}
}
// Delete this object from C++ memory.
func (this *QtPrivate__QPropertyBindingFunction) Delete() {
C.QtPrivate__QPropertyBindingFunction_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QPropertyBindingFunction) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QPropertyBindingFunction) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__QPropertyBindingData struct {
h *C.QtPrivate__QPropertyBindingData
isSubclass bool
}
func (this *QtPrivate__QPropertyBindingData) cPointer() *C.QtPrivate__QPropertyBindingData {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QPropertyBindingData) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QPropertyBindingData constructs the type using only CGO pointers.
func newQtPrivate__QPropertyBindingData(h *C.QtPrivate__QPropertyBindingData) *QtPrivate__QPropertyBindingData {
if h == nil {
return nil
}
return &QtPrivate__QPropertyBindingData{h: h}
}
// UnsafeNewQtPrivate__QPropertyBindingData constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QPropertyBindingData(h unsafe.Pointer) *QtPrivate__QPropertyBindingData {
if h == nil {
return nil
}
return &QtPrivate__QPropertyBindingData{h: (*C.QtPrivate__QPropertyBindingData)(h)}
}
// NewQtPrivate__QPropertyBindingData constructs a new QtPrivate::QPropertyBindingData object.
func NewQtPrivate__QPropertyBindingData() *QtPrivate__QPropertyBindingData {
var outptr_QtPrivate__QPropertyBindingData *C.QtPrivate__QPropertyBindingData = nil
C.QtPrivate__QPropertyBindingData_new(&outptr_QtPrivate__QPropertyBindingData)
ret := newQtPrivate__QPropertyBindingData(outptr_QtPrivate__QPropertyBindingData)
ret.isSubclass = true
return ret
}
func (this *QtPrivate__QPropertyBindingData) HasBinding() bool {
return (bool)(C.QtPrivate__QPropertyBindingData_HasBinding(this.h))
}
func (this *QtPrivate__QPropertyBindingData) IsNotificationDelayed() bool {
return (bool)(C.QtPrivate__QPropertyBindingData_IsNotificationDelayed(this.h))
}
func (this *QtPrivate__QPropertyBindingData) SetBinding(newBinding *QUntypedPropertyBinding, propertyDataPtr *QUntypedPropertyData) *QUntypedPropertyBinding {
_ret := C.QtPrivate__QPropertyBindingData_SetBinding(this.h, newBinding.cPointer(), propertyDataPtr.cPointer())
_goptr := newQUntypedPropertyBinding(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QtPrivate__QPropertyBindingData) EvaluateIfDirty(param1 *QUntypedPropertyData) {
C.QtPrivate__QPropertyBindingData_EvaluateIfDirty(this.h, param1.cPointer())
}
func (this *QtPrivate__QPropertyBindingData) RemoveBinding() {
C.QtPrivate__QPropertyBindingData_RemoveBinding(this.h)
}
func (this *QtPrivate__QPropertyBindingData) RegisterWithCurrentlyEvaluatingBinding2() {
C.QtPrivate__QPropertyBindingData_RegisterWithCurrentlyEvaluatingBinding2(this.h)
}
func (this *QtPrivate__QPropertyBindingData) NotifyObservers(propertyDataPtr *QUntypedPropertyData) {
C.QtPrivate__QPropertyBindingData_NotifyObservers(this.h, propertyDataPtr.cPointer())
}
func (this *QtPrivate__QPropertyBindingData) NotifyObservers2(propertyDataPtr *QUntypedPropertyData, storage *QBindingStorage) {
C.QtPrivate__QPropertyBindingData_NotifyObservers2(this.h, propertyDataPtr.cPointer(), storage.cPointer())
}
// Delete this object from C++ memory.
func (this *QtPrivate__QPropertyBindingData) Delete() {
C.QtPrivate__QPropertyBindingData_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QPropertyBindingData) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QPropertyBindingData) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

55
qt6/gen_qpropertyprivate.h
View File

@ -15,72 +15,17 @@ extern "C" {
#endif
#ifdef __cplusplus
class QBindingStorage;
class QPropertyProxyBindingData;
class QUntypedPropertyBinding;
class QUntypedPropertyData;
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__BindingFunctionVTable)
typedef QtPrivate::BindingFunctionVTable QtPrivate__BindingFunctionVTable;
#else
class QtPrivate__BindingFunctionVTable;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__MSVCWorkAround)
typedef QtPrivate::MSVCWorkAround QtPrivate__MSVCWorkAround;
#else
class QtPrivate__MSVCWorkAround;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QPropertyBindingData)
typedef QtPrivate::QPropertyBindingData QtPrivate__QPropertyBindingData;
#else
class QtPrivate__QPropertyBindingData;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QPropertyBindingFunction)
typedef QtPrivate::QPropertyBindingFunction QtPrivate__QPropertyBindingFunction;
#else
class QtPrivate__QPropertyBindingFunction;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__RefCounted)
typedef QtPrivate::RefCounted QtPrivate__RefCounted;
#else
class QtPrivate__RefCounted;
#endif
#else
typedef struct QBindingStorage QBindingStorage;
typedef struct QPropertyProxyBindingData QPropertyProxyBindingData;
typedef struct QUntypedPropertyBinding QUntypedPropertyBinding;
typedef struct QUntypedPropertyData QUntypedPropertyData;
typedef struct QtPrivate__BindingFunctionVTable QtPrivate__BindingFunctionVTable;
typedef struct QtPrivate__MSVCWorkAround QtPrivate__MSVCWorkAround;
typedef struct QtPrivate__QPropertyBindingData QtPrivate__QPropertyBindingData;
typedef struct QtPrivate__QPropertyBindingFunction QtPrivate__QPropertyBindingFunction;
typedef struct QtPrivate__RefCounted QtPrivate__RefCounted;
#endif
void QtPrivate__RefCounted_AddRef(QtPrivate__RefCounted* self);
bool QtPrivate__RefCounted_Deref(QtPrivate__RefCounted* self);
void QtPrivate__RefCounted_Delete(QtPrivate__RefCounted* self, bool isSubclass);
void QUntypedPropertyData_Delete(QUntypedPropertyData* self, bool isSubclass);
void QPropertyProxyBindingData_Delete(QPropertyProxyBindingData* self, bool isSubclass);
void QtPrivate__MSVCWorkAround_Delete(QtPrivate__MSVCWorkAround* self, bool isSubclass);
void QtPrivate__BindingFunctionVTable_Delete(QtPrivate__BindingFunctionVTable* self, bool isSubclass);
void QtPrivate__QPropertyBindingFunction_Delete(QtPrivate__QPropertyBindingFunction* self, bool isSubclass);
void QtPrivate__QPropertyBindingData_new(QtPrivate__QPropertyBindingData** outptr_QtPrivate__QPropertyBindingData);
bool QtPrivate__QPropertyBindingData_HasBinding(const QtPrivate__QPropertyBindingData* self);
bool QtPrivate__QPropertyBindingData_IsNotificationDelayed(const QtPrivate__QPropertyBindingData* self);
QUntypedPropertyBinding* QtPrivate__QPropertyBindingData_SetBinding(QtPrivate__QPropertyBindingData* self, QUntypedPropertyBinding* newBinding, QUntypedPropertyData* propertyDataPtr);
void QtPrivate__QPropertyBindingData_EvaluateIfDirty(const QtPrivate__QPropertyBindingData* self, QUntypedPropertyData* param1);
void QtPrivate__QPropertyBindingData_RemoveBinding(QtPrivate__QPropertyBindingData* self);
void QtPrivate__QPropertyBindingData_RegisterWithCurrentlyEvaluatingBinding2(const QtPrivate__QPropertyBindingData* self);
void QtPrivate__QPropertyBindingData_NotifyObservers(const QtPrivate__QPropertyBindingData* self, QUntypedPropertyData* propertyDataPtr);
void QtPrivate__QPropertyBindingData_NotifyObservers2(const QtPrivate__QPropertyBindingData* self, QUntypedPropertyData* propertyDataPtr, QBindingStorage* storage);
void QtPrivate__QPropertyBindingData_Delete(QtPrivate__QPropertyBindingData* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif

37
qt6/gen_qrefcount.cpp
View File

@ -1,37 +0,0 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__RefCount
#include <qrefcount.h>
#include "gen_qrefcount.h"
#include "_cgo_export.h"
bool QtPrivate__RefCount_Ref(QtPrivate__RefCount* self) {
return self->ref();
}
bool QtPrivate__RefCount_Deref(QtPrivate__RefCount* self) {
return self->deref();
}
bool QtPrivate__RefCount_IsStatic(const QtPrivate__RefCount* self) {
return self->isStatic();
}
bool QtPrivate__RefCount_IsShared(const QtPrivate__RefCount* self) {
return self->isShared();
}
void QtPrivate__RefCount_InitializeOwned(QtPrivate__RefCount* self) {
self->initializeOwned();
}
void QtPrivate__RefCount_InitializeUnsharable(QtPrivate__RefCount* self) {
self->initializeUnsharable();
}
void QtPrivate__RefCount_Delete(QtPrivate__RefCount* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::RefCount*>( self );
} else {
delete self;
}
}

88
qt6/gen_qrefcount.go
View File

@ -1,88 +0,0 @@
package qt6
/*
#include "gen_qrefcount.h"
#include <stdlib.h>
*/
import "C"
import (
"runtime"
"unsafe"
)
type QtPrivate__RefCount struct {
h *C.QtPrivate__RefCount
isSubclass bool
}
func (this *QtPrivate__RefCount) cPointer() *C.QtPrivate__RefCount {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__RefCount) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__RefCount constructs the type using only CGO pointers.
func newQtPrivate__RefCount(h *C.QtPrivate__RefCount) *QtPrivate__RefCount {
if h == nil {
return nil
}
return &QtPrivate__RefCount{h: h}
}
// UnsafeNewQtPrivate__RefCount constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__RefCount(h unsafe.Pointer) *QtPrivate__RefCount {
if h == nil {
return nil
}
return &QtPrivate__RefCount{h: (*C.QtPrivate__RefCount)(h)}
}
func (this *QtPrivate__RefCount) Ref() bool {
return (bool)(C.QtPrivate__RefCount_Ref(this.h))
}
func (this *QtPrivate__RefCount) Deref() bool {
return (bool)(C.QtPrivate__RefCount_Deref(this.h))
}
func (this *QtPrivate__RefCount) IsStatic() bool {
return (bool)(C.QtPrivate__RefCount_IsStatic(this.h))
}
func (this *QtPrivate__RefCount) IsShared() bool {
return (bool)(C.QtPrivate__RefCount_IsShared(this.h))
}
func (this *QtPrivate__RefCount) InitializeOwned() {
C.QtPrivate__RefCount_InitializeOwned(this.h)
}
func (this *QtPrivate__RefCount) InitializeUnsharable() {
C.QtPrivate__RefCount_InitializeUnsharable(this.h)
}
// Delete this object from C++ memory.
func (this *QtPrivate__RefCount) Delete() {
C.QtPrivate__RefCount_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__RefCount) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__RefCount) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

39
qt6/gen_qrefcount.h
View File

@ -1,39 +0,0 @@
#pragma once
#ifndef MIQT_QT6_GEN_QREFCOUNT_H
#define MIQT_QT6_GEN_QREFCOUNT_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__RefCount)
typedef QtPrivate::RefCount QtPrivate__RefCount;
#else
class QtPrivate__RefCount;
#endif
#else
typedef struct QtPrivate__RefCount QtPrivate__RefCount;
#endif
bool QtPrivate__RefCount_Ref(QtPrivate__RefCount* self);
bool QtPrivate__RefCount_Deref(QtPrivate__RefCount* self);
bool QtPrivate__RefCount_IsStatic(const QtPrivate__RefCount* self);
bool QtPrivate__RefCount_IsShared(const QtPrivate__RefCount* self);
void QtPrivate__RefCount_InitializeOwned(QtPrivate__RefCount* self);
void QtPrivate__RefCount_InitializeUnsharable(QtPrivate__RefCount* self);
void QtPrivate__RefCount_Delete(QtPrivate__RefCount* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

39
qt6/gen_qregularexpression.cpp
View File

@ -5,8 +5,6 @@
#include <QString>
#include <QByteArray>
#include <cstring>
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel
#include <qregularexpression.h>
#include "gen_qregularexpression.h"
#include "_cgo_export.h"
@ -385,19 +383,6 @@ void QRegularExpressionMatch_Delete(QRegularExpressionMatch* self, bool isSubcla
}
}
void QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel_new(QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel** outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel) {
QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel* ret = new QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel();
*outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel = ret;
}
void QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel_Delete(QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel*>( self );
} else {
delete self;
}
}
void QRegularExpressionMatchIterator_new(QRegularExpressionMatchIterator** outptr_QRegularExpressionMatchIterator) {
QRegularExpressionMatchIterator* ret = new QRegularExpressionMatchIterator();
*outptr_QRegularExpressionMatchIterator = ret;
@ -454,27 +439,3 @@ void QRegularExpressionMatchIterator_Delete(QRegularExpressionMatchIterator* sel
}
}
void QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator_new(QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator** outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator) {
QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIterator* ret = new QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIterator();
*outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator = ret;
}
void QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator_new2(QRegularExpressionMatchIterator* iterator, QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator** outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator) {
QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIterator* ret = new QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIterator(*iterator);
*outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator = ret;
}
QRegularExpressionMatch* QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator_OperatorMultiply(const QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator* self) {
const QRegularExpressionMatch& _ret = self->operator*();
// Cast returned reference into pointer
return const_cast<QRegularExpressionMatch*>(&_ret);
}
void QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator_Delete(QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIterator*>( self );
} else {
delete self;
}
}

134
qt6/gen_qregularexpression.go
View File

@ -563,66 +563,6 @@ func (this *QRegularExpressionMatch) GoGC() {
})
}
type QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel struct {
h *C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel
isSubclass bool
}
func (this *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel) cPointer() *C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel constructs the type using only CGO pointers.
func newQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel(h *C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel) *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel {
if h == nil {
return nil
}
return &QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel{h: h}
}
// UnsafeNewQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel(h unsafe.Pointer) *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel {
if h == nil {
return nil
}
return &QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel{h: (*C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel)(h)}
}
// NewQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel constructs a new QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel object.
func NewQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel() *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel {
var outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel *C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel = nil
C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel_new(&outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel)
ret := newQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel(outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel)
ret.isSubclass = true
return ret
}
// Delete this object from C++ memory.
func (this *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel) Delete() {
C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QRegularExpressionMatchIterator struct {
h *C.QRegularExpressionMatchIterator
isSubclass bool
@ -737,77 +677,3 @@ func (this *QRegularExpressionMatchIterator) GoGC() {
runtime.KeepAlive(this.h)
})
}
type QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator struct {
h *C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator
isSubclass bool
}
func (this *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator) cPointer() *C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator constructs the type using only CGO pointers.
func newQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator(h *C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator) *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator {
if h == nil {
return nil
}
return &QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator{h: h}
}
// UnsafeNewQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator(h unsafe.Pointer) *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator {
if h == nil {
return nil
}
return &QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator{h: (*C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator)(h)}
}
// NewQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator constructs a new QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIterator object.
func NewQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator() *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator {
var outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator *C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator = nil
C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator_new(&outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator)
ret := newQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator(outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator)
ret.isSubclass = true
return ret
}
// NewQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator2 constructs a new QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIterator object.
func NewQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator2(iterator *QRegularExpressionMatchIterator) *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator {
var outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator *C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator = nil
C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator_new2(iterator.cPointer(), &outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator)
ret := newQtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator(outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator)
ret.isSubclass = true
return ret
}
func (this *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator) OperatorMultiply() *QRegularExpressionMatch {
return UnsafeNewQRegularExpressionMatch(unsafe.Pointer(C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator_OperatorMultiply(this.h)))
}
// Delete this object from C++ memory.
func (this *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator) Delete() {
C.QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

20
qt6/gen_qregularexpression.h
View File

@ -18,22 +18,10 @@ extern "C" {
class QRegularExpression;
class QRegularExpressionMatch;
class QRegularExpressionMatchIterator;
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator)
typedef QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIterator QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator;
#else
class QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel)
typedef QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel;
#else
class QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel;
#endif
#else
typedef struct QRegularExpression QRegularExpression;
typedef struct QRegularExpressionMatch QRegularExpressionMatch;
typedef struct QRegularExpressionMatchIterator QRegularExpressionMatchIterator;
typedef struct QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator;
typedef struct QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel;
#endif
void QRegularExpression_new(QRegularExpression** outptr_QRegularExpression);
@ -96,9 +84,6 @@ ptrdiff_t QRegularExpressionMatch_CapturedLength1(const QRegularExpressionMatch*
ptrdiff_t QRegularExpressionMatch_CapturedEnd1(const QRegularExpressionMatch* self, int nth);
void QRegularExpressionMatch_Delete(QRegularExpressionMatch* self, bool isSubclass);
void QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel_new(QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel** outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel);
void QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel_Delete(QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel* self, bool isSubclass);
void QRegularExpressionMatchIterator_new(QRegularExpressionMatchIterator** outptr_QRegularExpressionMatchIterator);
void QRegularExpressionMatchIterator_new2(QRegularExpressionMatchIterator* iterator, QRegularExpressionMatchIterator** outptr_QRegularExpressionMatchIterator);
void QRegularExpressionMatchIterator_OperatorAssign(QRegularExpressionMatchIterator* self, QRegularExpressionMatchIterator* iterator);
@ -112,11 +97,6 @@ int QRegularExpressionMatchIterator_MatchType(const QRegularExpressionMatchItera
int QRegularExpressionMatchIterator_MatchOptions(const QRegularExpressionMatchIterator* self);
void QRegularExpressionMatchIterator_Delete(QRegularExpressionMatchIterator* self, bool isSubclass);
void QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator_new(QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator** outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator);
void QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator_new2(QRegularExpressionMatchIterator* iterator, QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator** outptr_QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator);
QRegularExpressionMatch* QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator_OperatorMultiply(const QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator* self);
void QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator_Delete(QtPrivate__QRegularExpressionMatchIteratorRangeBasedForIterator* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif

128
qt6/gen_qresultstore.cpp
View File

@ -1,128 +0,0 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ResultItem
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ResultIteratorBase
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ResultStoreBase
#include <qresultstore.h>
#include "gen_qresultstore.h"
#include "_cgo_export.h"
void QtPrivate__ResultItem_new(const void* _result, int _count, QtPrivate__ResultItem** outptr_QtPrivate__ResultItem) {
QtPrivate::ResultItem* ret = new QtPrivate::ResultItem(_result, static_cast<int>(_count));
*outptr_QtPrivate__ResultItem = ret;
}
void QtPrivate__ResultItem_new2(const void* _result, QtPrivate__ResultItem** outptr_QtPrivate__ResultItem) {
QtPrivate::ResultItem* ret = new QtPrivate::ResultItem(_result);
*outptr_QtPrivate__ResultItem = ret;
}
void QtPrivate__ResultItem_new3(QtPrivate__ResultItem** outptr_QtPrivate__ResultItem) {
QtPrivate::ResultItem* ret = new QtPrivate::ResultItem();
*outptr_QtPrivate__ResultItem = ret;
}
bool QtPrivate__ResultItem_IsValid(const QtPrivate__ResultItem* self) {
return self->isValid();
}
bool QtPrivate__ResultItem_IsVector(const QtPrivate__ResultItem* self) {
return self->isVector();
}
int QtPrivate__ResultItem_Count(const QtPrivate__ResultItem* self) {
return self->count();
}
void QtPrivate__ResultItem_Delete(QtPrivate__ResultItem* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::ResultItem*>( self );
} else {
delete self;
}
}
void QtPrivate__ResultIteratorBase_new(QtPrivate__ResultIteratorBase** outptr_QtPrivate__ResultIteratorBase) {
QtPrivate::ResultIteratorBase* ret = new QtPrivate::ResultIteratorBase();
*outptr_QtPrivate__ResultIteratorBase = ret;
}
int QtPrivate__ResultIteratorBase_VectorIndex(const QtPrivate__ResultIteratorBase* self) {
return self->vectorIndex();
}
int QtPrivate__ResultIteratorBase_ResultIndex(const QtPrivate__ResultIteratorBase* self) {
return self->resultIndex();
}
int QtPrivate__ResultIteratorBase_BatchSize(const QtPrivate__ResultIteratorBase* self) {
return self->batchSize();
}
void QtPrivate__ResultIteratorBase_BatchedAdvance(QtPrivate__ResultIteratorBase* self) {
self->batchedAdvance();
}
bool QtPrivate__ResultIteratorBase_IsVector(const QtPrivate__ResultIteratorBase* self) {
return self->isVector();
}
bool QtPrivate__ResultIteratorBase_CanIncrementVectorIndex(const QtPrivate__ResultIteratorBase* self) {
return self->canIncrementVectorIndex();
}
bool QtPrivate__ResultIteratorBase_IsValid(const QtPrivate__ResultIteratorBase* self) {
return self->isValid();
}
void QtPrivate__ResultIteratorBase_Delete(QtPrivate__ResultIteratorBase* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::ResultIteratorBase*>( self );
} else {
delete self;
}
}
void QtPrivate__ResultStoreBase_new(QtPrivate__ResultStoreBase** outptr_QtPrivate__ResultStoreBase) {
QtPrivate::ResultStoreBase* ret = new QtPrivate::ResultStoreBase();
*outptr_QtPrivate__ResultStoreBase = ret;
}
void QtPrivate__ResultStoreBase_SetFilterMode(QtPrivate__ResultStoreBase* self, bool enable) {
self->setFilterMode(enable);
}
bool QtPrivate__ResultStoreBase_FilterMode(const QtPrivate__ResultStoreBase* self) {
return self->filterMode();
}
int QtPrivate__ResultStoreBase_AddResult(QtPrivate__ResultStoreBase* self, int index, const void* result) {
return self->addResult(static_cast<int>(index), result);
}
int QtPrivate__ResultStoreBase_AddResults(QtPrivate__ResultStoreBase* self, int index, const void* results, int vectorSize, int logicalCount) {
return self->addResults(static_cast<int>(index), results, static_cast<int>(vectorSize), static_cast<int>(logicalCount));
}
bool QtPrivate__ResultStoreBase_HasNextResult(const QtPrivate__ResultStoreBase* self) {
return self->hasNextResult();
}
bool QtPrivate__ResultStoreBase_Contains(const QtPrivate__ResultStoreBase* self, int index) {
return self->contains(static_cast<int>(index));
}
int QtPrivate__ResultStoreBase_Count(const QtPrivate__ResultStoreBase* self) {
return self->count();
}
int QtPrivate__ResultStoreBase_AddCanceledResult(QtPrivate__ResultStoreBase* self, int index) {
return self->addCanceledResult(static_cast<int>(index));
}
void QtPrivate__ResultStoreBase_Delete(QtPrivate__ResultStoreBase* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::ResultStoreBase*>( self );
} else {
delete self;
}
}

286
qt6/gen_qresultstore.go
View File

@ -1,286 +0,0 @@
package qt6
/*
#include "gen_qresultstore.h"
#include <stdlib.h>
*/
import "C"
import (
"runtime"
"unsafe"
)
type QtPrivate__ResultItem struct {
h *C.QtPrivate__ResultItem
isSubclass bool
}
func (this *QtPrivate__ResultItem) cPointer() *C.QtPrivate__ResultItem {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__ResultItem) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__ResultItem constructs the type using only CGO pointers.
func newQtPrivate__ResultItem(h *C.QtPrivate__ResultItem) *QtPrivate__ResultItem {
if h == nil {
return nil
}
return &QtPrivate__ResultItem{h: h}
}
// UnsafeNewQtPrivate__ResultItem constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__ResultItem(h unsafe.Pointer) *QtPrivate__ResultItem {
if h == nil {
return nil
}
return &QtPrivate__ResultItem{h: (*C.QtPrivate__ResultItem)(h)}
}
// NewQtPrivate__ResultItem constructs a new QtPrivate::ResultItem object.
func NewQtPrivate__ResultItem(_result unsafe.Pointer, _count int) *QtPrivate__ResultItem {
var outptr_QtPrivate__ResultItem *C.QtPrivate__ResultItem = nil
C.QtPrivate__ResultItem_new(_result, (C.int)(_count), &outptr_QtPrivate__ResultItem)
ret := newQtPrivate__ResultItem(outptr_QtPrivate__ResultItem)
ret.isSubclass = true
return ret
}
// NewQtPrivate__ResultItem2 constructs a new QtPrivate::ResultItem object.
func NewQtPrivate__ResultItem2(_result unsafe.Pointer) *QtPrivate__ResultItem {
var outptr_QtPrivate__ResultItem *C.QtPrivate__ResultItem = nil
C.QtPrivate__ResultItem_new2(_result, &outptr_QtPrivate__ResultItem)
ret := newQtPrivate__ResultItem(outptr_QtPrivate__ResultItem)
ret.isSubclass = true
return ret
}
// NewQtPrivate__ResultItem3 constructs a new QtPrivate::ResultItem object.
func NewQtPrivate__ResultItem3() *QtPrivate__ResultItem {
var outptr_QtPrivate__ResultItem *C.QtPrivate__ResultItem = nil
C.QtPrivate__ResultItem_new3(&outptr_QtPrivate__ResultItem)
ret := newQtPrivate__ResultItem(outptr_QtPrivate__ResultItem)
ret.isSubclass = true
return ret
}
func (this *QtPrivate__ResultItem) IsValid() bool {
return (bool)(C.QtPrivate__ResultItem_IsValid(this.h))
}
func (this *QtPrivate__ResultItem) IsVector() bool {
return (bool)(C.QtPrivate__ResultItem_IsVector(this.h))
}
func (this *QtPrivate__ResultItem) Count() int {
return (int)(C.QtPrivate__ResultItem_Count(this.h))
}
// Delete this object from C++ memory.
func (this *QtPrivate__ResultItem) Delete() {
C.QtPrivate__ResultItem_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__ResultItem) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__ResultItem) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__ResultIteratorBase struct {
h *C.QtPrivate__ResultIteratorBase
isSubclass bool
}
func (this *QtPrivate__ResultIteratorBase) cPointer() *C.QtPrivate__ResultIteratorBase {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__ResultIteratorBase) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__ResultIteratorBase constructs the type using only CGO pointers.
func newQtPrivate__ResultIteratorBase(h *C.QtPrivate__ResultIteratorBase) *QtPrivate__ResultIteratorBase {
if h == nil {
return nil
}
return &QtPrivate__ResultIteratorBase{h: h}
}
// UnsafeNewQtPrivate__ResultIteratorBase constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__ResultIteratorBase(h unsafe.Pointer) *QtPrivate__ResultIteratorBase {
if h == nil {
return nil
}
return &QtPrivate__ResultIteratorBase{h: (*C.QtPrivate__ResultIteratorBase)(h)}
}
// NewQtPrivate__ResultIteratorBase constructs a new QtPrivate::ResultIteratorBase object.
func NewQtPrivate__ResultIteratorBase() *QtPrivate__ResultIteratorBase {
var outptr_QtPrivate__ResultIteratorBase *C.QtPrivate__ResultIteratorBase = nil
C.QtPrivate__ResultIteratorBase_new(&outptr_QtPrivate__ResultIteratorBase)
ret := newQtPrivate__ResultIteratorBase(outptr_QtPrivate__ResultIteratorBase)
ret.isSubclass = true
return ret
}
func (this *QtPrivate__ResultIteratorBase) VectorIndex() int {
return (int)(C.QtPrivate__ResultIteratorBase_VectorIndex(this.h))
}
func (this *QtPrivate__ResultIteratorBase) ResultIndex() int {
return (int)(C.QtPrivate__ResultIteratorBase_ResultIndex(this.h))
}
func (this *QtPrivate__ResultIteratorBase) BatchSize() int {
return (int)(C.QtPrivate__ResultIteratorBase_BatchSize(this.h))
}
func (this *QtPrivate__ResultIteratorBase) BatchedAdvance() {
C.QtPrivate__ResultIteratorBase_BatchedAdvance(this.h)
}
func (this *QtPrivate__ResultIteratorBase) IsVector() bool {
return (bool)(C.QtPrivate__ResultIteratorBase_IsVector(this.h))
}
func (this *QtPrivate__ResultIteratorBase) CanIncrementVectorIndex() bool {
return (bool)(C.QtPrivate__ResultIteratorBase_CanIncrementVectorIndex(this.h))
}
func (this *QtPrivate__ResultIteratorBase) IsValid() bool {
return (bool)(C.QtPrivate__ResultIteratorBase_IsValid(this.h))
}
// Delete this object from C++ memory.
func (this *QtPrivate__ResultIteratorBase) Delete() {
C.QtPrivate__ResultIteratorBase_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__ResultIteratorBase) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__ResultIteratorBase) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__ResultStoreBase struct {
h *C.QtPrivate__ResultStoreBase
isSubclass bool
}
func (this *QtPrivate__ResultStoreBase) cPointer() *C.QtPrivate__ResultStoreBase {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__ResultStoreBase) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__ResultStoreBase constructs the type using only CGO pointers.
func newQtPrivate__ResultStoreBase(h *C.QtPrivate__ResultStoreBase) *QtPrivate__ResultStoreBase {
if h == nil {
return nil
}
return &QtPrivate__ResultStoreBase{h: h}
}
// UnsafeNewQtPrivate__ResultStoreBase constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__ResultStoreBase(h unsafe.Pointer) *QtPrivate__ResultStoreBase {
if h == nil {
return nil
}
return &QtPrivate__ResultStoreBase{h: (*C.QtPrivate__ResultStoreBase)(h)}
}
// NewQtPrivate__ResultStoreBase constructs a new QtPrivate::ResultStoreBase object.
func NewQtPrivate__ResultStoreBase() *QtPrivate__ResultStoreBase {
var outptr_QtPrivate__ResultStoreBase *C.QtPrivate__ResultStoreBase = nil
C.QtPrivate__ResultStoreBase_new(&outptr_QtPrivate__ResultStoreBase)
ret := newQtPrivate__ResultStoreBase(outptr_QtPrivate__ResultStoreBase)
ret.isSubclass = true
return ret
}
func (this *QtPrivate__ResultStoreBase) SetFilterMode(enable bool) {
C.QtPrivate__ResultStoreBase_SetFilterMode(this.h, (C.bool)(enable))
}
func (this *QtPrivate__ResultStoreBase) FilterMode() bool {
return (bool)(C.QtPrivate__ResultStoreBase_FilterMode(this.h))
}
func (this *QtPrivate__ResultStoreBase) AddResult(index int, result unsafe.Pointer) int {
return (int)(C.QtPrivate__ResultStoreBase_AddResult(this.h, (C.int)(index), result))
}
func (this *QtPrivate__ResultStoreBase) AddResults(index int, results unsafe.Pointer, vectorSize int, logicalCount int) int {
return (int)(C.QtPrivate__ResultStoreBase_AddResults(this.h, (C.int)(index), results, (C.int)(vectorSize), (C.int)(logicalCount)))
}
func (this *QtPrivate__ResultStoreBase) HasNextResult() bool {
return (bool)(C.QtPrivate__ResultStoreBase_HasNextResult(this.h))
}
func (this *QtPrivate__ResultStoreBase) Contains(index int) bool {
return (bool)(C.QtPrivate__ResultStoreBase_Contains(this.h, (C.int)(index)))
}
func (this *QtPrivate__ResultStoreBase) Count() int {
return (int)(C.QtPrivate__ResultStoreBase_Count(this.h))
}
func (this *QtPrivate__ResultStoreBase) AddCanceledResult(index int) int {
return (int)(C.QtPrivate__ResultStoreBase_AddCanceledResult(this.h, (C.int)(index)))
}
// Delete this object from C++ memory.
func (this *QtPrivate__ResultStoreBase) Delete() {
C.QtPrivate__ResultStoreBase_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__ResultStoreBase) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__ResultStoreBase) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

72
qt6/gen_qresultstore.h
View File

@ -1,72 +0,0 @@
#pragma once
#ifndef MIQT_QT6_GEN_QRESULTSTORE_H
#define MIQT_QT6_GEN_QRESULTSTORE_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ResultItem)
typedef QtPrivate::ResultItem QtPrivate__ResultItem;
#else
class QtPrivate__ResultItem;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ResultIteratorBase)
typedef QtPrivate::ResultIteratorBase QtPrivate__ResultIteratorBase;
#else
class QtPrivate__ResultIteratorBase;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__ResultStoreBase)
typedef QtPrivate::ResultStoreBase QtPrivate__ResultStoreBase;
#else
class QtPrivate__ResultStoreBase;
#endif
#else
typedef struct QtPrivate__ResultItem QtPrivate__ResultItem;
typedef struct QtPrivate__ResultIteratorBase QtPrivate__ResultIteratorBase;
typedef struct QtPrivate__ResultStoreBase QtPrivate__ResultStoreBase;
#endif
void QtPrivate__ResultItem_new(const void* _result, int _count, QtPrivate__ResultItem** outptr_QtPrivate__ResultItem);
void QtPrivate__ResultItem_new2(const void* _result, QtPrivate__ResultItem** outptr_QtPrivate__ResultItem);
void QtPrivate__ResultItem_new3(QtPrivate__ResultItem** outptr_QtPrivate__ResultItem);
bool QtPrivate__ResultItem_IsValid(const QtPrivate__ResultItem* self);
bool QtPrivate__ResultItem_IsVector(const QtPrivate__ResultItem* self);
int QtPrivate__ResultItem_Count(const QtPrivate__ResultItem* self);
void QtPrivate__ResultItem_Delete(QtPrivate__ResultItem* self, bool isSubclass);
void QtPrivate__ResultIteratorBase_new(QtPrivate__ResultIteratorBase** outptr_QtPrivate__ResultIteratorBase);
int QtPrivate__ResultIteratorBase_VectorIndex(const QtPrivate__ResultIteratorBase* self);
int QtPrivate__ResultIteratorBase_ResultIndex(const QtPrivate__ResultIteratorBase* self);
int QtPrivate__ResultIteratorBase_BatchSize(const QtPrivate__ResultIteratorBase* self);
void QtPrivate__ResultIteratorBase_BatchedAdvance(QtPrivate__ResultIteratorBase* self);
bool QtPrivate__ResultIteratorBase_IsVector(const QtPrivate__ResultIteratorBase* self);
bool QtPrivate__ResultIteratorBase_CanIncrementVectorIndex(const QtPrivate__ResultIteratorBase* self);
bool QtPrivate__ResultIteratorBase_IsValid(const QtPrivate__ResultIteratorBase* self);
void QtPrivate__ResultIteratorBase_Delete(QtPrivate__ResultIteratorBase* self, bool isSubclass);
void QtPrivate__ResultStoreBase_new(QtPrivate__ResultStoreBase** outptr_QtPrivate__ResultStoreBase);
void QtPrivate__ResultStoreBase_SetFilterMode(QtPrivate__ResultStoreBase* self, bool enable);
bool QtPrivate__ResultStoreBase_FilterMode(const QtPrivate__ResultStoreBase* self);
int QtPrivate__ResultStoreBase_AddResult(QtPrivate__ResultStoreBase* self, int index, const void* result);
int QtPrivate__ResultStoreBase_AddResults(QtPrivate__ResultStoreBase* self, int index, const void* results, int vectorSize, int logicalCount);
bool QtPrivate__ResultStoreBase_HasNextResult(const QtPrivate__ResultStoreBase* self);
bool QtPrivate__ResultStoreBase_Contains(const QtPrivate__ResultStoreBase* self, int index);
int QtPrivate__ResultStoreBase_Count(const QtPrivate__ResultStoreBase* self);
int QtPrivate__ResultStoreBase_AddCanceledResult(QtPrivate__ResultStoreBase* self, int index);
void QtPrivate__ResultStoreBase_Delete(QtPrivate__ResultStoreBase* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

2
qt6/gen_qrubberband.cpp
View File

@ -867,7 +867,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QRubberBand_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qsizegrip.cpp
View File

@ -840,7 +840,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QSizeGrip_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qsocketnotifier.cpp
View File

@ -245,7 +245,7 @@ void QSocketNotifier_SetSocket(QSocketNotifier* self, intptr_t socket) {
intptr_t QSocketNotifier_Socket(const QSocketNotifier* self) {
qintptr _ret = self->socket();
return static_cast<intptr_t>(_ret);
return (intptr_t)(_ret);
}
int QSocketNotifier_Type(const QSocketNotifier* self) {

2
qt6/gen_qsplashscreen.cpp
View File

@ -848,7 +848,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QSplashScreen_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qsplitter.cpp
View File

@ -1341,7 +1341,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QSplitterHandle_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qstatusbar.cpp
View File

@ -817,7 +817,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QStatusBar_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qtabbar.cpp
View File

@ -1012,7 +1012,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QTabBar_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qtabwidget.cpp
View File

@ -916,7 +916,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QTabWidget_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

2
qt6/gen_qtestsupport_widgets.cpp
View File

@ -66,7 +66,7 @@ public:
void QTest__QTouchEventWidgetSequence_new(QTest__QTouchEventWidgetSequence* param1, QTest__QTouchEventWidgetSequence** outptr_QTest__QTouchEventWidgetSequence, QTest__QTouchEventSequence** outptr_QTest__QTouchEventSequence) {
MiqtVirtualQTestQTouchEventWidgetSequence* ret = new MiqtVirtualQTestQTouchEventWidgetSequence(*param1);
*outptr_QTest__QTouchEventWidgetSequence = ret;
*outptr_QTest::QTouchEventSequence = static_cast<QTest::QTouchEventSequence*>(ret);
*outptr_QTest__QTouchEventSequence = static_cast<QTest::QTouchEventSequence*>(ret);
}
QTest__QTouchEventWidgetSequence* QTest__QTouchEventWidgetSequence_Press(QTest__QTouchEventWidgetSequence* self, int touchId, QPoint* pt) {

138
qt6/gen_qtestsupport_widgets.go
View File

@ -14,147 +14,147 @@ import (
"unsafe"
)
type QTest__QTouchEventWidgetSequence struct {
type QTest__QTouchEventWidgetSequence struct {
h *C.QTest__QTouchEventWidgetSequence
isSubclass bool
*QTest__QTouchEventSequence
}
}
func (this *QTest__QTouchEventWidgetSequence) cPointer() *C.QTest__QTouchEventWidgetSequence {
func (this *QTest__QTouchEventWidgetSequence) cPointer() *C.QTest__QTouchEventWidgetSequence {
if this == nil {
return nil
}
return this.h
}
}
func (this *QTest__QTouchEventWidgetSequence) UnsafePointer() unsafe.Pointer {
func (this *QTest__QTouchEventWidgetSequence) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
}
// newQTest__QTouchEventWidgetSequence constructs the type using only CGO pointers.
func newQTest__QTouchEventWidgetSequence(h *C.QTest__QTouchEventWidgetSequence, h_QTest__QTouchEventSequence *C.QTest__QTouchEventSequence) *QTest__QTouchEventWidgetSequence {
// newQTest__QTouchEventWidgetSequence constructs the type using only CGO pointers.
func newQTest__QTouchEventWidgetSequence(h *C.QTest__QTouchEventWidgetSequence, h_QTest__QTouchEventSequence *C.QTest__QTouchEventSequence) *QTest__QTouchEventWidgetSequence {
if h == nil {
return nil
}
return &QTest__QTouchEventWidgetSequence{h: h,
QTest__QTouchEventSequence: newQTest__QTouchEventSequence(h_QTest__QTouchEventSequence)}
}
QTest__QTouchEventSequence: newQTest__QTouchEventSequence(h_QTest__QTouchEventSequence)}
}
// UnsafeNewQTest__QTouchEventWidgetSequence constructs the type using only unsafe pointers.
func UnsafeNewQTest__QTouchEventWidgetSequence(h unsafe.Pointer, h_QTest__QTouchEventSequence unsafe.Pointer) *QTest__QTouchEventWidgetSequence {
// UnsafeNewQTest__QTouchEventWidgetSequence constructs the type using only unsafe pointers.
func UnsafeNewQTest__QTouchEventWidgetSequence(h unsafe.Pointer, h_QTest__QTouchEventSequence unsafe.Pointer) *QTest__QTouchEventWidgetSequence {
if h == nil {
return nil
}
return &QTest__QTouchEventWidgetSequence{h: (*C.QTest__QTouchEventWidgetSequence)(h),
QTest__QTouchEventSequence: UnsafeNewQTest__QTouchEventSequence(h_QTest__QTouchEventSequence)}
}
QTest__QTouchEventSequence: UnsafeNewQTest__QTouchEventSequence(h_QTest__QTouchEventSequence)}
}
// NewQTest__QTouchEventWidgetSequence constructs a new QTest::QTouchEventWidgetSequence object.
func NewQTest__QTouchEventWidgetSequence(param1 *QTest__QTouchEventWidgetSequence) *QTest__QTouchEventWidgetSequence {
// NewQTest__QTouchEventWidgetSequence constructs a new QTest::QTouchEventWidgetSequence object.
func NewQTest__QTouchEventWidgetSequence(param1 *QTest__QTouchEventWidgetSequence) *QTest__QTouchEventWidgetSequence {
var outptr_QTest__QTouchEventWidgetSequence *C.QTest__QTouchEventWidgetSequence = nil
var outptr_QTest__QTouchEventSequence *C.QTest::QTouchEventSequence = nil
var outptr_QTest__QTouchEventSequence *C.QTest__QTouchEventSequence = nil
C.QTest__QTouchEventWidgetSequence_new(param1.cPointer(), &outptr_QTest__QTouchEventWidgetSequence, &outptr_QTest__QTouchEventSequence)
ret := newQTest__QTouchEventWidgetSequence(outptr_QTest__QTouchEventWidgetSequence, outptr_QTest__QTouchEventSequence)
ret.isSubclass = true
return ret
}
}
func (this *QTest__QTouchEventWidgetSequence) Press(touchId int, pt *QPoint) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Press(this.h, (C.int)(touchId), pt.cPointer())), nil)
}
func (this *QTest__QTouchEventWidgetSequence) Press(touchId int, pt *QPoint) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Press(this.h, (C.int)(touchId), pt.cPointer())), nil)}
func (this *QTest__QTouchEventWidgetSequence) Move(touchId int, pt *QPoint) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Move(this.h, (C.int)(touchId), pt.cPointer())), nil)
}
func (this *QTest__QTouchEventWidgetSequence) Move(touchId int, pt *QPoint) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Move(this.h, (C.int)(touchId), pt.cPointer())), nil)}
func (this *QTest__QTouchEventWidgetSequence) Release(touchId int, pt *QPoint) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Release(this.h, (C.int)(touchId), pt.cPointer())), nil)
}
func (this *QTest__QTouchEventWidgetSequence) Release(touchId int, pt *QPoint) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Release(this.h, (C.int)(touchId), pt.cPointer())), nil)}
func (this *QTest__QTouchEventWidgetSequence) Stationary(touchId int) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Stationary(this.h, (C.int)(touchId))), nil)
}
func (this *QTest__QTouchEventWidgetSequence) Stationary(touchId int) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Stationary(this.h, (C.int)(touchId))), nil)}
func (this *QTest__QTouchEventWidgetSequence) Commit(processEvents bool) bool {
func (this *QTest__QTouchEventWidgetSequence) Commit(processEvents bool) bool {
return (bool)(C.QTest__QTouchEventWidgetSequence_Commit(this.h, (C.bool)(processEvents)))
}
func (this *QTest__QTouchEventWidgetSequence) Press3(touchId int, pt *QPoint, widget *QWidget) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Press3(this.h, (C.int)(touchId), pt.cPointer(), widget.cPointer())), nil)}
func (this *QTest__QTouchEventWidgetSequence) Press3(touchId int, pt *QPoint, widget *QWidget) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Press3(this.h, (C.int)(touchId), pt.cPointer(), widget.cPointer())), nil)
}
func (this *QTest__QTouchEventWidgetSequence) Move3(touchId int, pt *QPoint, widget *QWidget) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Move3(this.h, (C.int)(touchId), pt.cPointer(), widget.cPointer())), nil)}
func (this *QTest__QTouchEventWidgetSequence) Move3(touchId int, pt *QPoint, widget *QWidget) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Move3(this.h, (C.int)(touchId), pt.cPointer(), widget.cPointer())), nil)
}
func (this *QTest__QTouchEventWidgetSequence) Release3(touchId int, pt *QPoint, widget *QWidget) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Release3(this.h, (C.int)(touchId), pt.cPointer(), widget.cPointer())), nil)}
func (this *QTest__QTouchEventWidgetSequence) Release3(touchId int, pt *QPoint, widget *QWidget) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_Release3(this.h, (C.int)(touchId), pt.cPointer(), widget.cPointer())), nil)
}
func (this *QTest__QTouchEventWidgetSequence) callVirtualBase_Stationary(touchId int) *QTest__QTouchEventWidgetSequence {
func (this *QTest__QTouchEventWidgetSequence) callVirtualBase_Stationary(touchId int) *QTest__QTouchEventWidgetSequence {
return UnsafeNewQTest__QTouchEventWidgetSequence(unsafe.Pointer(C.QTest__QTouchEventWidgetSequence_virtualbase_Stationary(unsafe.Pointer(this.h), (C.int)(touchId))), nil)
}
func (this *QTest__QTouchEventWidgetSequence) OnStationary(slot func(super func(touchId int) *QTest__QTouchEventWidgetSequence, touchId int) *QTest__QTouchEventWidgetSequence) {
C.QTest__QTouchEventWidgetSequence_override_virtual_Stationary(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)) )
}
}
func (this *QTest__QTouchEventWidgetSequence) OnStationary(slot func(super func(touchId int) *QTest__QTouchEventWidgetSequence, touchId int) *QTest__QTouchEventWidgetSequence) {
C.QTest__QTouchEventWidgetSequence_override_virtual_Stationary(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QTest__QTouchEventWidgetSequence_Stationary
func miqt_exec_callback_QTest__QTouchEventWidgetSequence_Stationary(self *C.QTest__QTouchEventWidgetSequence, cb C.intptr_t, touchId C.int) *C.QTest__QTouchEventWidgetSequence{
//export miqt_exec_callback_QTest__QTouchEventWidgetSequence_Stationary
func miqt_exec_callback_QTest__QTouchEventWidgetSequence_Stationary(self *C.QTest__QTouchEventWidgetSequence, cb C.intptr_t, touchId C.int) *C.QTest__QTouchEventWidgetSequence {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(touchId int) *QTest__QTouchEventWidgetSequence, touchId int) *QTest__QTouchEventWidgetSequence)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := (int)(touchId)
slotval1 := (int)(touchId)
virtualReturn := gofunc((&QTest__QTouchEventWidgetSequence{h: self}).callVirtualBase_Stationary, slotval1)
virtualReturn := gofunc((&QTest__QTouchEventWidgetSequence{h: self}).callVirtualBase_Stationary, slotval1 )
return virtualReturn.cPointer()
return virtualReturn.cPointer()
}
}
func (this *QTest__QTouchEventWidgetSequence) callVirtualBase_Commit(processEvents bool) bool {
func (this *QTest__QTouchEventWidgetSequence) callVirtualBase_Commit(processEvents bool) bool {
return (bool)(C.QTest__QTouchEventWidgetSequence_virtualbase_Commit(unsafe.Pointer(this.h), (C.bool)(processEvents)))
}
func (this *QTest__QTouchEventWidgetSequence) OnCommit(slot func(super func(processEvents bool) bool, processEvents bool) bool) {
C.QTest__QTouchEventWidgetSequence_override_virtual_Commit(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)) )
}
}
func (this *QTest__QTouchEventWidgetSequence) OnCommit(slot func(super func(processEvents bool) bool, processEvents bool) bool) {
C.QTest__QTouchEventWidgetSequence_override_virtual_Commit(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
}
//export miqt_exec_callback_QTest__QTouchEventWidgetSequence_Commit
func miqt_exec_callback_QTest__QTouchEventWidgetSequence_Commit(self *C.QTest__QTouchEventWidgetSequence, cb C.intptr_t, processEvents C.bool) C.bool{
//export miqt_exec_callback_QTest__QTouchEventWidgetSequence_Commit
func miqt_exec_callback_QTest__QTouchEventWidgetSequence_Commit(self *C.QTest__QTouchEventWidgetSequence, cb C.intptr_t, processEvents C.bool) C.bool {
gofunc, ok := cgo.Handle(cb).Value().(func(super func(processEvents bool) bool, processEvents bool) bool)
if !ok {
panic("miqt: callback of non-callback type (heap corruption?)")
}
// Convert all CABI parameters to Go parameters
slotval1 := (bool)(processEvents)
slotval1 := (bool)(processEvents)
virtualReturn := gofunc((&QTest__QTouchEventWidgetSequence{h: self}).callVirtualBase_Commit, slotval1)
virtualReturn := gofunc((&QTest__QTouchEventWidgetSequence{h: self}).callVirtualBase_Commit, slotval1 )
return (C.bool)(virtualReturn)
return (C.bool)(virtualReturn)
}
}
// Delete this object from C++ memory.
func (this *QTest__QTouchEventWidgetSequence) Delete() {
// Delete this object from C++ memory.
func (this *QTest__QTouchEventWidgetSequence) Delete() {
C.QTest__QTouchEventWidgetSequence_Delete(this.h, C.bool(this.isSubclass))
}
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QTest__QTouchEventWidgetSequence) GoGC() {
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QTest__QTouchEventWidgetSequence) GoGC() {
runtime.SetFinalizer(this, func(this *QTest__QTouchEventWidgetSequence) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
}

2
qt6/gen_qtoolbar.cpp
View File

@ -870,7 +870,7 @@ public:
struct miqt_string sigval1 = eventType_ms;
void* sigval2 = message;
qintptr* result_ret = result;
intptr_t* sigval3 = static_cast<intptr_t*>(result_ret);
intptr_t* sigval3 = (intptr_t*)(result_ret);
bool callback_return_value = miqt_exec_callback_QToolBar_NativeEvent(this, handle__NativeEvent, sigval1, sigval2, sigval3);

22
qt6/gen_qutf8stringview.cpp
View File

@ -1,22 +0,0 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__hide_char8_t
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__wrap_char
#include <qutf8stringview.h>
#include "gen_qutf8stringview.h"
#include "_cgo_export.h"
void QtPrivate__hide_char8_t_Delete(QtPrivate__hide_char8_t* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::hide_char8_t*>( self );
} else {
delete self;
}
}
void QtPrivate__wrap_char_Delete(QtPrivate__wrap_char* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::wrap_char*>( self );
} else {
delete self;
}
}

114
qt6/gen_qutf8stringview.go
View File

@ -1,114 +0,0 @@
package qt6
/*
#include "gen_qutf8stringview.h"
#include <stdlib.h>
*/
import "C"
import (
"runtime"
"unsafe"
)
type QtPrivate__hide_char8_t struct {
h *C.QtPrivate__hide_char8_t
isSubclass bool
}
func (this *QtPrivate__hide_char8_t) cPointer() *C.QtPrivate__hide_char8_t {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__hide_char8_t) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__hide_char8_t constructs the type using only CGO pointers.
func newQtPrivate__hide_char8_t(h *C.QtPrivate__hide_char8_t) *QtPrivate__hide_char8_t {
if h == nil {
return nil
}
return &QtPrivate__hide_char8_t{h: h}
}
// UnsafeNewQtPrivate__hide_char8_t constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__hide_char8_t(h unsafe.Pointer) *QtPrivate__hide_char8_t {
if h == nil {
return nil
}
return &QtPrivate__hide_char8_t{h: (*C.QtPrivate__hide_char8_t)(h)}
}
// Delete this object from C++ memory.
func (this *QtPrivate__hide_char8_t) Delete() {
C.QtPrivate__hide_char8_t_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__hide_char8_t) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__hide_char8_t) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QtPrivate__wrap_char struct {
h *C.QtPrivate__wrap_char
isSubclass bool
}
func (this *QtPrivate__wrap_char) cPointer() *C.QtPrivate__wrap_char {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__wrap_char) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__wrap_char constructs the type using only CGO pointers.
func newQtPrivate__wrap_char(h *C.QtPrivate__wrap_char) *QtPrivate__wrap_char {
if h == nil {
return nil
}
return &QtPrivate__wrap_char{h: h}
}
// UnsafeNewQtPrivate__wrap_char constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__wrap_char(h unsafe.Pointer) *QtPrivate__wrap_char {
if h == nil {
return nil
}
return &QtPrivate__wrap_char{h: (*C.QtPrivate__wrap_char)(h)}
}
// Delete this object from C++ memory.
func (this *QtPrivate__wrap_char) Delete() {
C.QtPrivate__wrap_char_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__wrap_char) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__wrap_char) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

41
qt6/gen_qutf8stringview.h
View File

@ -1,41 +0,0 @@
#pragma once
#ifndef MIQT_QT6_GEN_QUTF8STRINGVIEW_H
#define MIQT_QT6_GEN_QUTF8STRINGVIEW_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__hide_char8_t)
typedef QtPrivate::hide_char8_t QtPrivate__hide_char8_t;
#else
class QtPrivate__hide_char8_t;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__wrap_char)
typedef QtPrivate::wrap_char QtPrivate__wrap_char;
#else
class QtPrivate__wrap_char;
#endif
#else
typedef struct QtPrivate__hide_char8_t QtPrivate__hide_char8_t;
typedef struct QtPrivate__wrap_char QtPrivate__wrap_char;
#endif
void QtPrivate__hide_char8_t_Delete(QtPrivate__hide_char8_t* self, bool isSubclass);
void QtPrivate__wrap_char_Delete(QtPrivate__wrap_char* self, bool isSubclass);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

17
qt6/gen_qvariant.cpp
View File

@ -33,7 +33,6 @@
#include <QUuid>
#include <QVariant>
#include <QVariantConstPointer>
#define WORKAROUND_INNER_CLASS_DEFINITION_QtPrivate__QVariantTypeCoercer
#include <qvariant.h>
#include "gen_qvariant.h"
#include "_cgo_export.h"
@ -640,22 +639,6 @@ void QVariant_Delete(QVariant* self, bool isSubclass) {
}
}
const void* QtPrivate__QVariantTypeCoercer_Convert(QtPrivate__QVariantTypeCoercer* self, QVariant* value, QMetaType* typeVal) {
return (const void*) self->convert(*value, *typeVal);
}
const void* QtPrivate__QVariantTypeCoercer_Coerce(QtPrivate__QVariantTypeCoercer* self, QVariant* value, QMetaType* typeVal) {
return (const void*) self->coerce(*value, *typeVal);
}
void QtPrivate__QVariantTypeCoercer_Delete(QtPrivate__QVariantTypeCoercer* self, bool isSubclass) {
if (isSubclass) {
delete dynamic_cast<QtPrivate::QVariantTypeCoercer*>( self );
} else {
delete self;
}
}
void QVariantConstPointer_new(QVariant* variant, QVariantConstPointer** outptr_QVariantConstPointer) {
QVariantConstPointer* ret = new QVariantConstPointer(*variant);
*outptr_QVariantConstPointer = ret;

58
qt6/gen_qvariant.go
View File

@ -1014,64 +1014,6 @@ func (this *QVariant) GoGC() {
})
}
type QtPrivate__QVariantTypeCoercer struct {
h *C.QtPrivate__QVariantTypeCoercer
isSubclass bool
}
func (this *QtPrivate__QVariantTypeCoercer) cPointer() *C.QtPrivate__QVariantTypeCoercer {
if this == nil {
return nil
}
return this.h
}
func (this *QtPrivate__QVariantTypeCoercer) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQtPrivate__QVariantTypeCoercer constructs the type using only CGO pointers.
func newQtPrivate__QVariantTypeCoercer(h *C.QtPrivate__QVariantTypeCoercer) *QtPrivate__QVariantTypeCoercer {
if h == nil {
return nil
}
return &QtPrivate__QVariantTypeCoercer{h: h}
}
// UnsafeNewQtPrivate__QVariantTypeCoercer constructs the type using only unsafe pointers.
func UnsafeNewQtPrivate__QVariantTypeCoercer(h unsafe.Pointer) *QtPrivate__QVariantTypeCoercer {
if h == nil {
return nil
}
return &QtPrivate__QVariantTypeCoercer{h: (*C.QtPrivate__QVariantTypeCoercer)(h)}
}
func (this *QtPrivate__QVariantTypeCoercer) Convert(value *QVariant, typeVal *QMetaType) unsafe.Pointer {
return (unsafe.Pointer)(C.QtPrivate__QVariantTypeCoercer_Convert(this.h, value.cPointer(), typeVal.cPointer()))
}
func (this *QtPrivate__QVariantTypeCoercer) Coerce(value *QVariant, typeVal *QMetaType) unsafe.Pointer {
return (unsafe.Pointer)(C.QtPrivate__QVariantTypeCoercer_Coerce(this.h, value.cPointer(), typeVal.cPointer()))
}
// Delete this object from C++ memory.
func (this *QtPrivate__QVariantTypeCoercer) Delete() {
C.QtPrivate__QVariantTypeCoercer_Delete(this.h, C.bool(this.isSubclass))
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QtPrivate__QVariantTypeCoercer) GoGC() {
runtime.SetFinalizer(this, func(this *QtPrivate__QVariantTypeCoercer) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QVariantConstPointer struct {
h *C.QVariantConstPointer
isSubclass bool

Some files were not shown because too many files have changed in this diff Show More