From d66a0915bf577935077c8a09f86ad9f39363064d Mon Sep 17 00:00:00 2001 From: mappu Date: Fri, 11 Apr 2025 22:56:11 +1200 Subject: [PATCH] qt: rebuild (allow QVariantList methods) [BREAKING] --- qt/cbor/gen_qcborarray.cpp | 24 +++++++++++++++++ qt/cbor/gen_qcborarray.go | 24 +++++++++++++++++ qt/cbor/gen_qcborarray.h | 4 +++ qt/gen_qjsonarray.cpp | 24 +++++++++++++++++ qt/gen_qjsonarray.go | 24 +++++++++++++++++ qt/gen_qjsonarray.h | 4 +++ qt/gen_qstatemachine.cpp | 26 +++++++++++++++++- qt/gen_qstatemachine.go | 28 ++++++++++++++++++-- qt/gen_qstatemachine.h | 6 ++++- qt/gen_qvariant.cpp | 23 ++++++++++++++++ qt/gen_qvariant.go | 24 +++++++++++++++++ qt/gen_qvariant.h | 2 ++ qt/multimedia/gen_qcameraexposurecontrol.cpp | 14 ++++++++++ qt/multimedia/gen_qcameraexposurecontrol.go | 12 +++++++++ qt/multimedia/gen_qcameraexposurecontrol.h | 1 + qt6/cbor/gen_qcborarray.cpp | 24 +++++++++++++++++ qt6/cbor/gen_qcborarray.go | 24 +++++++++++++++++ qt6/cbor/gen_qcborarray.h | 4 +++ qt6/gen_qjsonarray.cpp | 24 +++++++++++++++++ qt6/gen_qjsonarray.go | 24 +++++++++++++++++ qt6/gen_qjsonarray.h | 4 +++ qt6/gen_qvariant.cpp | 23 ++++++++++++++++ qt6/gen_qvariant.go | 24 +++++++++++++++++ qt6/gen_qvariant.h | 2 ++ 24 files changed, 389 insertions(+), 4 deletions(-) diff --git a/qt/cbor/gen_qcborarray.cpp b/qt/cbor/gen_qcborarray.cpp index e9fc975b..fc7ba231 100644 --- a/qt/cbor/gen_qcborarray.cpp +++ b/qt/cbor/gen_qcborarray.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include "gen_qcborarray.h" @@ -239,10 +240,33 @@ QCborArray* QCborArray_fromStringList(struct miqt_array /* of struct miqt_string return new QCborArray(QCborArray::fromStringList(list_QList)); } +QCborArray* QCborArray_fromVariantList(struct miqt_array /* of QVariant* */ list) { + QVariantList list_QList; + list_QList.reserve(list.len); + QVariant** list_arr = static_cast(list.data); + for(size_t i = 0; i < list.len; ++i) { + list_QList.push_back(*(list_arr[i])); + } + return new QCborArray(QCborArray::fromVariantList(list_QList)); +} + QCborArray* QCborArray_fromJsonArray(QJsonArray* array) { return new QCborArray(QCborArray::fromJsonArray(*array)); } +struct miqt_array /* of QVariant* */ QCborArray_toVariantList(const QCborArray* self) { + QVariantList _ret = self->toVariantList(); + // Convert QList<> from C++ memory to manually-managed C memory + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QVariant(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + QJsonArray* QCborArray_toJsonArray(const QCborArray* self) { return new QJsonArray(self->toJsonArray()); } diff --git a/qt/cbor/gen_qcborarray.go b/qt/cbor/gen_qcborarray.go index c195fe19..e043b3e2 100644 --- a/qt/cbor/gen_qcborarray.go +++ b/qt/cbor/gen_qcborarray.go @@ -322,12 +322,36 @@ func QCborArray_FromStringList(list []string) *QCborArray { return _goptr } +func QCborArray_FromVariantList(list []qt.QVariant) *QCborArray { + list_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(list)))) + defer C.free(unsafe.Pointer(list_CArray)) + for i := range list { + list_CArray[i] = (*C.QVariant)(list[i].UnsafePointer()) + } + list_ma := C.struct_miqt_array{len: C.size_t(len(list)), data: unsafe.Pointer(list_CArray)} + _goptr := newQCborArray(C.QCborArray_fromVariantList(list_ma)) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + func QCborArray_FromJsonArray(array *qt.QJsonArray) *QCborArray { _goptr := newQCborArray(C.QCborArray_fromJsonArray((*C.QJsonArray)(array.UnsafePointer()))) _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer return _goptr } +func (this *QCborArray) ToVariantList() []qt.QVariant { + var _ma C.struct_miqt_array = C.QCborArray_toVariantList(this.h) + _ret := make([]qt.QVariant, int(_ma.len)) + _outCast := (*[0xffff]*C.QVariant)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(_outCast[i])) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret +} + func (this *QCborArray) ToJsonArray() *qt.QJsonArray { _goptr := qt.UnsafeNewQJsonArray(unsafe.Pointer(C.QCborArray_toJsonArray(this.h))) _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer diff --git a/qt/cbor/gen_qcborarray.h b/qt/cbor/gen_qcborarray.h index 856da692..75f185fa 100644 --- a/qt/cbor/gen_qcborarray.h +++ b/qt/cbor/gen_qcborarray.h @@ -29,6 +29,7 @@ class QCborArray__Iterator; class QCborValue; class QCborValueRef; class QJsonArray; +class QVariant; #else typedef struct QCborArray QCborArray; typedef struct QCborArray__ConstIterator QCborArray__ConstIterator; @@ -36,6 +37,7 @@ typedef struct QCborArray__Iterator QCborArray__Iterator; typedef struct QCborValue QCborValue; typedef struct QCborValueRef QCborValueRef; typedef struct QJsonArray QJsonArray; +typedef struct QVariant QVariant; #endif QCborArray* QCborArray_new(); @@ -90,7 +92,9 @@ QCborArray* QCborArray_operatorPlus(const QCborArray* self, QCborValue* v); QCborArray* QCborArray_operatorPlusAssign(QCborArray* self, QCborValue* v); QCborArray* QCborArray_operatorShiftLeft(QCborArray* self, QCborValue* v); QCborArray* QCborArray_fromStringList(struct miqt_array /* of struct miqt_string */ list); +QCborArray* QCborArray_fromVariantList(struct miqt_array /* of QVariant* */ list); QCborArray* QCborArray_fromJsonArray(QJsonArray* array); +struct miqt_array /* of QVariant* */ QCborArray_toVariantList(const QCborArray* self); QJsonArray* QCborArray_toJsonArray(const QCborArray* self); void QCborArray_delete(QCborArray* self); diff --git a/qt/gen_qjsonarray.cpp b/qt/gen_qjsonarray.cpp index 41225b2d..5da2c7e0 100644 --- a/qt/gen_qjsonarray.cpp +++ b/qt/gen_qjsonarray.cpp @@ -9,6 +9,7 @@ #include #include #include +#include #include #include "gen_qjsonarray.h" @@ -43,6 +44,29 @@ QJsonArray* QJsonArray_fromStringList(struct miqt_array /* of struct miqt_string return new QJsonArray(QJsonArray::fromStringList(list_QList)); } +QJsonArray* QJsonArray_fromVariantList(struct miqt_array /* of QVariant* */ list) { + QVariantList list_QList; + list_QList.reserve(list.len); + QVariant** list_arr = static_cast(list.data); + for(size_t i = 0; i < list.len; ++i) { + list_QList.push_back(*(list_arr[i])); + } + return new QJsonArray(QJsonArray::fromVariantList(list_QList)); +} + +struct miqt_array /* of QVariant* */ QJsonArray_toVariantList(const QJsonArray* self) { + QVariantList _ret = self->toVariantList(); + // Convert QList<> from C++ memory to manually-managed C memory + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QVariant(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + int QJsonArray_size(const QJsonArray* self) { return self->size(); } diff --git a/qt/gen_qjsonarray.go b/qt/gen_qjsonarray.go index 5de9eb2a..dbc3b07c 100644 --- a/qt/gen_qjsonarray.go +++ b/qt/gen_qjsonarray.go @@ -77,6 +77,30 @@ func QJsonArray_FromStringList(list []string) *QJsonArray { return _goptr } +func QJsonArray_FromVariantList(list []QVariant) *QJsonArray { + list_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(list)))) + defer C.free(unsafe.Pointer(list_CArray)) + for i := range list { + list_CArray[i] = list[i].cPointer() + } + list_ma := C.struct_miqt_array{len: C.size_t(len(list)), data: unsafe.Pointer(list_CArray)} + _goptr := newQJsonArray(C.QJsonArray_fromVariantList(list_ma)) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QJsonArray) ToVariantList() []QVariant { + var _ma C.struct_miqt_array = C.QJsonArray_toVariantList(this.h) + _ret := make([]QVariant, int(_ma.len)) + _outCast := (*[0xffff]*C.QVariant)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := newQVariant(_outCast[i]) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret +} + func (this *QJsonArray) Size() int { return (int)(C.QJsonArray_size(this.h)) } diff --git a/qt/gen_qjsonarray.h b/qt/gen_qjsonarray.h index 75acb221..9c5880d7 100644 --- a/qt/gen_qjsonarray.h +++ b/qt/gen_qjsonarray.h @@ -30,6 +30,7 @@ class QJsonValue; class QJsonValuePtr; class QJsonValueRef; class QJsonValueRefPtr; +class QVariant; #else typedef struct QJsonArray QJsonArray; typedef struct QJsonArray__const_iterator QJsonArray__const_iterator; @@ -38,12 +39,15 @@ typedef struct QJsonValue QJsonValue; typedef struct QJsonValuePtr QJsonValuePtr; typedef struct QJsonValueRef QJsonValueRef; typedef struct QJsonValueRefPtr QJsonValueRefPtr; +typedef struct QVariant QVariant; #endif QJsonArray* QJsonArray_new(); QJsonArray* QJsonArray_new2(QJsonArray* other); void QJsonArray_operatorAssign(QJsonArray* self, QJsonArray* other); QJsonArray* QJsonArray_fromStringList(struct miqt_array /* of struct miqt_string */ list); +QJsonArray* QJsonArray_fromVariantList(struct miqt_array /* of QVariant* */ list); +struct miqt_array /* of QVariant* */ QJsonArray_toVariantList(const QJsonArray* self); int QJsonArray_size(const QJsonArray* self); int QJsonArray_count(const QJsonArray* self); bool QJsonArray_isEmpty(const QJsonArray* self); diff --git a/qt/gen_qstatemachine.cpp b/qt/gen_qstatemachine.cpp index ad9f7a6e..37154584 100644 --- a/qt/gen_qstatemachine.cpp +++ b/qt/gen_qstatemachine.cpp @@ -15,6 +15,7 @@ #include #include #include +#include #include #include "gen_qstatemachine.h" @@ -793,7 +794,17 @@ void QStateMachine_delete(QStateMachine* self) { delete self; } -QStateMachine__SignalEvent* QStateMachine__SignalEvent_new(QStateMachine__SignalEvent* param1) { +QStateMachine__SignalEvent* QStateMachine__SignalEvent_new(QObject* sender, int signalIndex, struct miqt_array /* of QVariant* */ arguments) { + QList arguments_QList; + arguments_QList.reserve(arguments.len); + QVariant** arguments_arr = static_cast(arguments.data); + for(size_t i = 0; i < arguments.len; ++i) { + arguments_QList.push_back(*(arguments_arr[i])); + } + return new QStateMachine::SignalEvent(sender, static_cast(signalIndex), arguments_QList); +} + +QStateMachine__SignalEvent* QStateMachine__SignalEvent_new2(QStateMachine__SignalEvent* param1) { return new QStateMachine::SignalEvent(*param1); } @@ -809,6 +820,19 @@ int QStateMachine__SignalEvent_signalIndex(const QStateMachine__SignalEvent* sel return self->signalIndex(); } +struct miqt_array /* of QVariant* */ QStateMachine__SignalEvent_arguments(const QStateMachine__SignalEvent* self) { + QList _ret = self->arguments(); + // Convert QList<> from C++ memory to manually-managed C memory + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QVariant(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + void QStateMachine__SignalEvent_delete(QStateMachine__SignalEvent* self) { delete self; } diff --git a/qt/gen_qstatemachine.go b/qt/gen_qstatemachine.go index 1c21e809..db3fc2dd 100644 --- a/qt/gen_qstatemachine.go +++ b/qt/gen_qstatemachine.go @@ -741,9 +741,21 @@ func UnsafeNewQStateMachine__SignalEvent(h unsafe.Pointer) *QStateMachine__Signa } // NewQStateMachine__SignalEvent constructs a new QStateMachine::SignalEvent object. -func NewQStateMachine__SignalEvent(param1 *QStateMachine__SignalEvent) *QStateMachine__SignalEvent { +func NewQStateMachine__SignalEvent(sender *QObject, signalIndex int, arguments []QVariant) *QStateMachine__SignalEvent { + arguments_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(arguments)))) + defer C.free(unsafe.Pointer(arguments_CArray)) + for i := range arguments { + arguments_CArray[i] = arguments[i].cPointer() + } + arguments_ma := C.struct_miqt_array{len: C.size_t(len(arguments)), data: unsafe.Pointer(arguments_CArray)} - return newQStateMachine__SignalEvent(C.QStateMachine__SignalEvent_new(param1.cPointer())) + return newQStateMachine__SignalEvent(C.QStateMachine__SignalEvent_new(sender.cPointer(), (C.int)(signalIndex), arguments_ma)) +} + +// NewQStateMachine__SignalEvent2 constructs a new QStateMachine::SignalEvent object. +func NewQStateMachine__SignalEvent2(param1 *QStateMachine__SignalEvent) *QStateMachine__SignalEvent { + + return newQStateMachine__SignalEvent(C.QStateMachine__SignalEvent_new2(param1.cPointer())) } func (this *QStateMachine__SignalEvent) Sender() *QObject { @@ -754,6 +766,18 @@ func (this *QStateMachine__SignalEvent) SignalIndex() int { return (int)(C.QStateMachine__SignalEvent_signalIndex(this.h)) } +func (this *QStateMachine__SignalEvent) Arguments() []QVariant { + var _ma C.struct_miqt_array = C.QStateMachine__SignalEvent_arguments(this.h) + _ret := make([]QVariant, int(_ma.len)) + _outCast := (*[0xffff]*C.QVariant)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := newQVariant(_outCast[i]) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret +} + // Delete this object from C++ memory. func (this *QStateMachine__SignalEvent) Delete() { C.QStateMachine__SignalEvent_delete(this.h) diff --git a/qt/gen_qstatemachine.h b/qt/gen_qstatemachine.h index 3c331346..9f8489bb 100644 --- a/qt/gen_qstatemachine.h +++ b/qt/gen_qstatemachine.h @@ -35,6 +35,7 @@ typedef QStateMachine::WrappedEvent QStateMachine__WrappedEvent; class QStateMachine__WrappedEvent; #endif class QTimerEvent; +class QVariant; #else typedef struct QAbstractAnimation QAbstractAnimation; typedef struct QAbstractState QAbstractState; @@ -48,6 +49,7 @@ typedef struct QStateMachine QStateMachine; typedef struct QStateMachine__SignalEvent QStateMachine__SignalEvent; typedef struct QStateMachine__WrappedEvent QStateMachine__WrappedEvent; typedef struct QTimerEvent QTimerEvent; +typedef struct QVariant QVariant; #endif QStateMachine* QStateMachine_new(); @@ -126,10 +128,12 @@ int QStateMachine_protectedbase_receivers(bool* _dynamic_cast_ok, const void* se bool QStateMachine_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); void QStateMachine_delete(QStateMachine* self); -QStateMachine__SignalEvent* QStateMachine__SignalEvent_new(QStateMachine__SignalEvent* param1); +QStateMachine__SignalEvent* QStateMachine__SignalEvent_new(QObject* sender, int signalIndex, struct miqt_array /* of QVariant* */ arguments); +QStateMachine__SignalEvent* QStateMachine__SignalEvent_new2(QStateMachine__SignalEvent* param1); void QStateMachine__SignalEvent_virtbase(QStateMachine__SignalEvent* src, QEvent** outptr_QEvent); QObject* QStateMachine__SignalEvent_sender(const QStateMachine__SignalEvent* self); int QStateMachine__SignalEvent_signalIndex(const QStateMachine__SignalEvent* self); +struct miqt_array /* of QVariant* */ QStateMachine__SignalEvent_arguments(const QStateMachine__SignalEvent* self); void QStateMachine__SignalEvent_delete(QStateMachine__SignalEvent* self); QStateMachine__WrappedEvent* QStateMachine__WrappedEvent_new(QObject* object, QEvent* event); diff --git a/qt/gen_qvariant.cpp b/qt/gen_qvariant.cpp index 51397145..3e1c6ebd 100644 --- a/qt/gen_qvariant.cpp +++ b/qt/gen_qvariant.cpp @@ -247,6 +247,16 @@ QVariant* QVariant_new44(QPersistentModelIndex* modelIndex) { return new QVariant(*modelIndex); } +QVariant* QVariant_new45(struct miqt_array /* of QVariant* */ list) { + QList list_QList; + list_QList.reserve(list.len); + QVariant** list_arr = static_cast(list.data); + for(size_t i = 0; i < list.len; ++i) { + list_QList.push_back(*(list_arr[i])); + } + return new QVariant(list_QList); +} + void QVariant_operatorAssign(QVariant* self, QVariant* other) { self->operator=(*other); } @@ -392,6 +402,19 @@ QDateTime* QVariant_toDateTime(const QVariant* self) { return new QDateTime(self->toDateTime()); } +struct miqt_array /* of QVariant* */ QVariant_toList(const QVariant* self) { + QList _ret = self->toList(); + // Convert QList<> from C++ memory to manually-managed C memory + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QVariant(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + struct miqt_map /* of struct miqt_string to QVariant* */ QVariant_toMap(const QVariant* self) { QMap _ret = self->toMap(); // Convert QMap<> from C++ memory to manually-managed C memory diff --git a/qt/gen_qvariant.go b/qt/gen_qvariant.go index 680f27cf..3e830fb5 100644 --- a/qt/gen_qvariant.go +++ b/qt/gen_qvariant.go @@ -436,6 +436,18 @@ func NewQVariant44(modelIndex *QPersistentModelIndex) *QVariant { return newQVariant(C.QVariant_new44(modelIndex.cPointer())) } +// NewQVariant45 constructs a new QVariant object. +func NewQVariant45(list []QVariant) *QVariant { + list_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(list)))) + defer C.free(unsafe.Pointer(list_CArray)) + for i := range list { + list_CArray[i] = list[i].cPointer() + } + list_ma := C.struct_miqt_array{len: C.size_t(len(list)), data: unsafe.Pointer(list_CArray)} + + return newQVariant(C.QVariant_new45(list_ma)) +} + func (this *QVariant) OperatorAssign(other *QVariant) { C.QVariant_operatorAssign(this.h, other.cPointer()) } @@ -574,6 +586,18 @@ func (this *QVariant) ToDateTime() *QDateTime { return _goptr } +func (this *QVariant) ToList() []QVariant { + var _ma C.struct_miqt_array = C.QVariant_toList(this.h) + _ret := make([]QVariant, int(_ma.len)) + _outCast := (*[0xffff]*C.QVariant)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := newQVariant(_outCast[i]) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret +} + func (this *QVariant) ToMap() map[string]QVariant { var _mm C.struct_miqt_map = C.QVariant_toMap(this.h) _ret := make(map[string]QVariant, int(_mm.len)) diff --git a/qt/gen_qvariant.h b/qt/gen_qvariant.h index 633942fd..9fee04d6 100644 --- a/qt/gen_qvariant.h +++ b/qt/gen_qvariant.h @@ -136,6 +136,7 @@ QVariant* QVariant_new41(QJsonArray* jsonArray); QVariant* QVariant_new42(QJsonDocument* jsonDocument); QVariant* QVariant_new43(QModelIndex* modelIndex); QVariant* QVariant_new44(QPersistentModelIndex* modelIndex); +QVariant* QVariant_new45(struct miqt_array /* of QVariant* */ list); void QVariant_operatorAssign(QVariant* self, QVariant* other); void QVariant_swap(QVariant* self, QVariant* other); int QVariant_type(const QVariant* self); @@ -164,6 +165,7 @@ QChar* QVariant_toChar(const QVariant* self); QDate* QVariant_toDate(const QVariant* self); QTime* QVariant_toTime(const QVariant* self); QDateTime* QVariant_toDateTime(const QVariant* self); +struct miqt_array /* of QVariant* */ QVariant_toList(const QVariant* self); struct miqt_map /* of struct miqt_string to QVariant* */ QVariant_toMap(const QVariant* self); struct miqt_map /* of struct miqt_string to QVariant* */ QVariant_toHash(const QVariant* self); QPoint* QVariant_toPoint(const QVariant* self); diff --git a/qt/multimedia/gen_qcameraexposurecontrol.cpp b/qt/multimedia/gen_qcameraexposurecontrol.cpp index 5560818c..2cd4ae68 100644 --- a/qt/multimedia/gen_qcameraexposurecontrol.cpp +++ b/qt/multimedia/gen_qcameraexposurecontrol.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -59,6 +60,19 @@ bool QCameraExposureControl_isParameterSupported(const QCameraExposureControl* s return self->isParameterSupported(static_cast(parameter)); } +struct miqt_array /* of QVariant* */ QCameraExposureControl_supportedParameterRange(const QCameraExposureControl* self, int parameter, bool* continuous) { + QVariantList _ret = self->supportedParameterRange(static_cast(parameter), continuous); + // Convert QList<> from C++ memory to manually-managed C memory + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QVariant(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + QVariant* QCameraExposureControl_requestedValue(const QCameraExposureControl* self, int parameter) { return new QVariant(self->requestedValue(static_cast(parameter))); } diff --git a/qt/multimedia/gen_qcameraexposurecontrol.go b/qt/multimedia/gen_qcameraexposurecontrol.go index 43f5e73b..040323f4 100644 --- a/qt/multimedia/gen_qcameraexposurecontrol.go +++ b/qt/multimedia/gen_qcameraexposurecontrol.go @@ -99,6 +99,18 @@ func (this *QCameraExposureControl) IsParameterSupported(parameter QCameraExposu return (bool)(C.QCameraExposureControl_isParameterSupported(this.h, (C.int)(parameter))) } +func (this *QCameraExposureControl) SupportedParameterRange(parameter QCameraExposureControl__ExposureParameter, continuous *bool) []qt.QVariant { + var _ma C.struct_miqt_array = C.QCameraExposureControl_supportedParameterRange(this.h, (C.int)(parameter), (*C.bool)(unsafe.Pointer(continuous))) + _ret := make([]qt.QVariant, int(_ma.len)) + _outCast := (*[0xffff]*C.QVariant)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(_outCast[i])) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret +} + func (this *QCameraExposureControl) RequestedValue(parameter QCameraExposureControl__ExposureParameter) *qt.QVariant { _goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QCameraExposureControl_requestedValue(this.h, (C.int)(parameter)))) _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer diff --git a/qt/multimedia/gen_qcameraexposurecontrol.h b/qt/multimedia/gen_qcameraexposurecontrol.h index 44117b56..f71c2e18 100644 --- a/qt/multimedia/gen_qcameraexposurecontrol.h +++ b/qt/multimedia/gen_qcameraexposurecontrol.h @@ -36,6 +36,7 @@ void* QCameraExposureControl_metacast(QCameraExposureControl* self, const char* struct miqt_string QCameraExposureControl_tr(const char* s); struct miqt_string QCameraExposureControl_trUtf8(const char* s); bool QCameraExposureControl_isParameterSupported(const QCameraExposureControl* self, int parameter); +struct miqt_array /* of QVariant* */ QCameraExposureControl_supportedParameterRange(const QCameraExposureControl* self, int parameter, bool* continuous); QVariant* QCameraExposureControl_requestedValue(const QCameraExposureControl* self, int parameter); QVariant* QCameraExposureControl_actualValue(const QCameraExposureControl* self, int parameter); bool QCameraExposureControl_setValue(QCameraExposureControl* self, int parameter, QVariant* value); diff --git a/qt6/cbor/gen_qcborarray.cpp b/qt6/cbor/gen_qcborarray.cpp index 2ff9e888..bf09eb32 100644 --- a/qt6/cbor/gen_qcborarray.cpp +++ b/qt6/cbor/gen_qcborarray.cpp @@ -9,6 +9,7 @@ #include #include #include +#include #include #include "gen_qcborarray.h" @@ -240,10 +241,33 @@ QCborArray* QCborArray_fromStringList(struct miqt_array /* of struct miqt_string return new QCborArray(QCborArray::fromStringList(list_QList)); } +QCborArray* QCborArray_fromVariantList(struct miqt_array /* of QVariant* */ list) { + QVariantList list_QList; + list_QList.reserve(list.len); + QVariant** list_arr = static_cast(list.data); + for(size_t i = 0; i < list.len; ++i) { + list_QList.push_back(*(list_arr[i])); + } + return new QCborArray(QCborArray::fromVariantList(list_QList)); +} + QCborArray* QCborArray_fromJsonArray(QJsonArray* array) { return new QCborArray(QCborArray::fromJsonArray(*array)); } +struct miqt_array /* of QVariant* */ QCborArray_toVariantList(const QCborArray* self) { + QVariantList _ret = self->toVariantList(); + // Convert QList<> from C++ memory to manually-managed C memory + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QVariant(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + QJsonArray* QCborArray_toJsonArray(const QCborArray* self) { return new QJsonArray(self->toJsonArray()); } diff --git a/qt6/cbor/gen_qcborarray.go b/qt6/cbor/gen_qcborarray.go index 6d429b69..cc31a7fb 100644 --- a/qt6/cbor/gen_qcborarray.go +++ b/qt6/cbor/gen_qcborarray.go @@ -322,12 +322,36 @@ func QCborArray_FromStringList(list []string) *QCborArray { return _goptr } +func QCborArray_FromVariantList(list []qt6.QVariant) *QCborArray { + list_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(list)))) + defer C.free(unsafe.Pointer(list_CArray)) + for i := range list { + list_CArray[i] = (*C.QVariant)(list[i].UnsafePointer()) + } + list_ma := C.struct_miqt_array{len: C.size_t(len(list)), data: unsafe.Pointer(list_CArray)} + _goptr := newQCborArray(C.QCborArray_fromVariantList(list_ma)) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + func QCborArray_FromJsonArray(array *qt6.QJsonArray) *QCborArray { _goptr := newQCborArray(C.QCborArray_fromJsonArray((*C.QJsonArray)(array.UnsafePointer()))) _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer return _goptr } +func (this *QCborArray) ToVariantList() []qt6.QVariant { + var _ma C.struct_miqt_array = C.QCborArray_toVariantList(this.h) + _ret := make([]qt6.QVariant, int(_ma.len)) + _outCast := (*[0xffff]*C.QVariant)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(_outCast[i])) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret +} + func (this *QCborArray) ToJsonArray() *qt6.QJsonArray { _goptr := qt6.UnsafeNewQJsonArray(unsafe.Pointer(C.QCborArray_toJsonArray(this.h))) _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer diff --git a/qt6/cbor/gen_qcborarray.h b/qt6/cbor/gen_qcborarray.h index 7eb14411..86b16122 100644 --- a/qt6/cbor/gen_qcborarray.h +++ b/qt6/cbor/gen_qcborarray.h @@ -30,6 +30,7 @@ class QCborValue; class QCborValueConstRef; class QCborValueRef; class QJsonArray; +class QVariant; #else typedef struct QCborArray QCborArray; typedef struct QCborArray__ConstIterator QCborArray__ConstIterator; @@ -38,6 +39,7 @@ typedef struct QCborValue QCborValue; typedef struct QCborValueConstRef QCborValueConstRef; typedef struct QCborValueRef QCborValueRef; typedef struct QJsonArray QJsonArray; +typedef struct QVariant QVariant; #endif QCborArray* QCborArray_new(); @@ -92,7 +94,9 @@ QCborArray* QCborArray_operatorPlus(const QCborArray* self, QCborValue* v); QCborArray* QCborArray_operatorPlusAssign(QCborArray* self, QCborValue* v); QCborArray* QCborArray_operatorShiftLeft(QCborArray* self, QCborValue* v); QCborArray* QCborArray_fromStringList(struct miqt_array /* of struct miqt_string */ list); +QCborArray* QCborArray_fromVariantList(struct miqt_array /* of QVariant* */ list); QCborArray* QCborArray_fromJsonArray(QJsonArray* array); +struct miqt_array /* of QVariant* */ QCborArray_toVariantList(const QCborArray* self); QJsonArray* QCborArray_toJsonArray(const QCborArray* self); void QCborArray_delete(QCborArray* self); diff --git a/qt6/gen_qjsonarray.cpp b/qt6/gen_qjsonarray.cpp index 3b3f37e2..57c5be5a 100644 --- a/qt6/gen_qjsonarray.cpp +++ b/qt6/gen_qjsonarray.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include "gen_qjsonarray.h" @@ -42,6 +43,29 @@ QJsonArray* QJsonArray_fromStringList(struct miqt_array /* of struct miqt_string return new QJsonArray(QJsonArray::fromStringList(list_QList)); } +QJsonArray* QJsonArray_fromVariantList(struct miqt_array /* of QVariant* */ list) { + QVariantList list_QList; + list_QList.reserve(list.len); + QVariant** list_arr = static_cast(list.data); + for(size_t i = 0; i < list.len; ++i) { + list_QList.push_back(*(list_arr[i])); + } + return new QJsonArray(QJsonArray::fromVariantList(list_QList)); +} + +struct miqt_array /* of QVariant* */ QJsonArray_toVariantList(const QJsonArray* self) { + QVariantList _ret = self->toVariantList(); + // Convert QList<> from C++ memory to manually-managed C memory + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QVariant(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + ptrdiff_t QJsonArray_size(const QJsonArray* self) { qsizetype _ret = self->size(); return static_cast(_ret); diff --git a/qt6/gen_qjsonarray.go b/qt6/gen_qjsonarray.go index a22ba98d..d7645f29 100644 --- a/qt6/gen_qjsonarray.go +++ b/qt6/gen_qjsonarray.go @@ -77,6 +77,30 @@ func QJsonArray_FromStringList(list []string) *QJsonArray { return _goptr } +func QJsonArray_FromVariantList(list []QVariant) *QJsonArray { + list_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(list)))) + defer C.free(unsafe.Pointer(list_CArray)) + for i := range list { + list_CArray[i] = list[i].cPointer() + } + list_ma := C.struct_miqt_array{len: C.size_t(len(list)), data: unsafe.Pointer(list_CArray)} + _goptr := newQJsonArray(C.QJsonArray_fromVariantList(list_ma)) + _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + return _goptr +} + +func (this *QJsonArray) ToVariantList() []QVariant { + var _ma C.struct_miqt_array = C.QJsonArray_toVariantList(this.h) + _ret := make([]QVariant, int(_ma.len)) + _outCast := (*[0xffff]*C.QVariant)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := newQVariant(_outCast[i]) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret +} + func (this *QJsonArray) Size() int64 { return (int64)(C.QJsonArray_size(this.h)) } diff --git a/qt6/gen_qjsonarray.h b/qt6/gen_qjsonarray.h index 96a95c91..c56bc79e 100644 --- a/qt6/gen_qjsonarray.h +++ b/qt6/gen_qjsonarray.h @@ -29,6 +29,7 @@ class QJsonArray__iterator; class QJsonValue; class QJsonValueConstRef; class QJsonValueRef; +class QVariant; #else typedef struct QJsonArray QJsonArray; typedef struct QJsonArray__const_iterator QJsonArray__const_iterator; @@ -36,12 +37,15 @@ typedef struct QJsonArray__iterator QJsonArray__iterator; typedef struct QJsonValue QJsonValue; typedef struct QJsonValueConstRef QJsonValueConstRef; typedef struct QJsonValueRef QJsonValueRef; +typedef struct QVariant QVariant; #endif QJsonArray* QJsonArray_new(); QJsonArray* QJsonArray_new2(QJsonArray* other); void QJsonArray_operatorAssign(QJsonArray* self, QJsonArray* other); QJsonArray* QJsonArray_fromStringList(struct miqt_array /* of struct miqt_string */ list); +QJsonArray* QJsonArray_fromVariantList(struct miqt_array /* of QVariant* */ list); +struct miqt_array /* of QVariant* */ QJsonArray_toVariantList(const QJsonArray* self); ptrdiff_t QJsonArray_size(const QJsonArray* self); ptrdiff_t QJsonArray_count(const QJsonArray* self); bool QJsonArray_isEmpty(const QJsonArray* self); diff --git a/qt6/gen_qvariant.cpp b/qt6/gen_qvariant.cpp index 83bff70e..a16d1a42 100644 --- a/qt6/gen_qvariant.cpp +++ b/qt6/gen_qvariant.cpp @@ -237,6 +237,16 @@ QVariant* QVariant_new42(QMetaType* type, const void* copy) { return new QVariant(*type, copy); } +QVariant* QVariant_new43(struct miqt_array /* of QVariant* */ list) { + QList list_QList; + list_QList.reserve(list.len); + QVariant** list_arr = static_cast(list.data); + for(size_t i = 0; i < list.len; ++i) { + list_QList.push_back(*(list_arr[i])); + } + return new QVariant(list_QList); +} + void QVariant_operatorAssign(QVariant* self, QVariant* other) { self->operator=(*other); } @@ -397,6 +407,19 @@ QDateTime* QVariant_toDateTime(const QVariant* self) { return new QDateTime(self->toDateTime()); } +struct miqt_array /* of QVariant* */ QVariant_toList(const QVariant* self) { + QList _ret = self->toList(); + // Convert QList<> from C++ memory to manually-managed C memory + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); + for (size_t i = 0, e = _ret.length(); i < e; ++i) { + _arr[i] = new QVariant(_ret[i]); + } + struct miqt_array _out; + _out.len = _ret.length(); + _out.data = static_cast(_arr); + return _out; +} + struct miqt_map /* of struct miqt_string to QVariant* */ QVariant_toMap(const QVariant* self) { QMap _ret = self->toMap(); // Convert QMap<> from C++ memory to manually-managed C memory diff --git a/qt6/gen_qvariant.go b/qt6/gen_qvariant.go index cf87dc55..bbb885c7 100644 --- a/qt6/gen_qvariant.go +++ b/qt6/gen_qvariant.go @@ -422,6 +422,18 @@ func NewQVariant42(typeVal QMetaType, copyVal unsafe.Pointer) *QVariant { return newQVariant(C.QVariant_new42(typeVal.cPointer(), copyVal)) } +// NewQVariant43 constructs a new QVariant object. +func NewQVariant43(list []QVariant) *QVariant { + list_CArray := (*[0xffff]*C.QVariant)(C.malloc(C.size_t(8 * len(list)))) + defer C.free(unsafe.Pointer(list_CArray)) + for i := range list { + list_CArray[i] = list[i].cPointer() + } + list_ma := C.struct_miqt_array{len: C.size_t(len(list)), data: unsafe.Pointer(list_CArray)} + + return newQVariant(C.QVariant_new43(list_ma)) +} + func (this *QVariant) OperatorAssign(other *QVariant) { C.QVariant_operatorAssign(this.h, other.cPointer()) } @@ -578,6 +590,18 @@ func (this *QVariant) ToDateTime() *QDateTime { return _goptr } +func (this *QVariant) ToList() []QVariant { + var _ma C.struct_miqt_array = C.QVariant_toList(this.h) + _ret := make([]QVariant, int(_ma.len)) + _outCast := (*[0xffff]*C.QVariant)(unsafe.Pointer(_ma.data)) // hey ya + for i := 0; i < int(_ma.len); i++ { + _lv_goptr := newQVariant(_outCast[i]) + _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer + _ret[i] = *_lv_goptr + } + return _ret +} + func (this *QVariant) ToMap() map[string]QVariant { var _mm C.struct_miqt_map = C.QVariant_toMap(this.h) _ret := make(map[string]QVariant, int(_mm.len)) diff --git a/qt6/gen_qvariant.h b/qt6/gen_qvariant.h index 2c16c62f..69d822bb 100644 --- a/qt6/gen_qvariant.h +++ b/qt6/gen_qvariant.h @@ -118,6 +118,7 @@ QVariant* QVariant_new39(QModelIndex* modelIndex); QVariant* QVariant_new40(QPersistentModelIndex* modelIndex); QVariant* QVariant_new41(int type); QVariant* QVariant_new42(QMetaType* type, const void* copy); +QVariant* QVariant_new43(struct miqt_array /* of QVariant* */ list); void QVariant_operatorAssign(QVariant* self, QVariant* other); void QVariant_swap(QVariant* self, QVariant* other); int QVariant_userType(const QVariant* self); @@ -150,6 +151,7 @@ QChar* QVariant_toChar(const QVariant* self); QDate* QVariant_toDate(const QVariant* self); QTime* QVariant_toTime(const QVariant* self); QDateTime* QVariant_toDateTime(const QVariant* self); +struct miqt_array /* of QVariant* */ QVariant_toList(const QVariant* self); struct miqt_map /* of struct miqt_string to QVariant* */ QVariant_toMap(const QVariant* self); struct miqt_map /* of struct miqt_string to QVariant* */ QVariant_toHash(const QVariant* self); QPoint* QVariant_toPoint(const QVariant* self);