qt: rebuild (allow QVariantList methods) [BREAKING]

qt/cbor/gen_qcborarray.cpp

@@ -8,6 +8,7 @@
 #include <QString>
 #include <QByteArray>
 #include <cstring>
+#include <QVariant>
 #include <qcborarray.h>
 #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<QVariant**>(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<QVariant**>(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<void*>(_arr);
+	return _out;
+}
+
 QJsonArray* QCborArray_toJsonArray(const QCborArray* self) {
 	return new QJsonArray(self->toJsonArray());
 }

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

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);
 

qt/gen_qjsonarray.cpp

@@ -9,6 +9,7 @@
 #include <QString>
 #include <QByteArray>
 #include <cstring>
+#include <QVariant>
 #include <qjsonarray.h>
 #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<QVariant**>(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<QVariant**>(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<void*>(_arr);
+	return _out;
+}
+
 int QJsonArray_size(const QJsonArray* self) {
 	return self->size();
 }

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))
 }

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);

qt/gen_qstatemachine.cpp

@@ -15,6 +15,7 @@
 #include <QByteArray>
 #include <cstring>
 #include <QTimerEvent>
+#include <QVariant>
 #include <qstatemachine.h>
 #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<QVariant> arguments_QList;
+	arguments_QList.reserve(arguments.len);
+	QVariant** arguments_arr = static_cast<QVariant**>(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<int>(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<QVariant> _ret = self->arguments();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	QVariant** _arr = static_cast<QVariant**>(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<void*>(_arr);
+	return _out;
+}
+
 void QStateMachine__SignalEvent_delete(QStateMachine__SignalEvent* self) {
 	delete self;
 }

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)

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);

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<QVariant> list_QList;
+	list_QList.reserve(list.len);
+	QVariant** list_arr = static_cast<QVariant**>(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<QVariant> _ret = self->toList();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	QVariant** _arr = static_cast<QVariant**>(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<void*>(_arr);
+	return _out;
+}
+
 struct miqt_map /* of struct miqt_string to QVariant* */  QVariant_toMap(const QVariant* self) {
 	QMap<QString, QVariant> _ret = self->toMap();
 	// Convert QMap<> from C++ memory to manually-managed C memory

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))

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);

qt/multimedia/gen_qcameraexposurecontrol.cpp

@@ -1,4 +1,5 @@
 #include <QCameraExposureControl>
+#include <QList>
 #include <QMediaControl>
 #include <QMetaMethod>
 #include <QMetaObject>
@@ -59,6 +60,19 @@ bool QCameraExposureControl_isParameterSupported(const QCameraExposureControl* s
 	return self->isParameterSupported(static_cast<QCameraExposureControl::ExposureParameter>(parameter));
 }
 
+struct miqt_array /* of QVariant* */  QCameraExposureControl_supportedParameterRange(const QCameraExposureControl* self, int parameter, bool* continuous) {
+	QVariantList _ret = self->supportedParameterRange(static_cast<QCameraExposureControl::ExposureParameter>(parameter), continuous);
+	// Convert QList<> from C++ memory to manually-managed C memory
+	QVariant** _arr = static_cast<QVariant**>(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<void*>(_arr);
+	return _out;
+}
+
 QVariant* QCameraExposureControl_requestedValue(const QCameraExposureControl* self, int parameter) {
 	return new QVariant(self->requestedValue(static_cast<QCameraExposureControl::ExposureParameter>(parameter)));
 }

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

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);

qt6/cbor/gen_qcborarray.cpp

@@ -9,6 +9,7 @@
 #include <QString>
 #include <QByteArray>
 #include <cstring>
+#include <QVariant>
 #include <qcborarray.h>
 #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<QVariant**>(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<QVariant**>(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<void*>(_arr);
+	return _out;
+}
+
 QJsonArray* QCborArray_toJsonArray(const QCborArray* self) {
 	return new QJsonArray(self->toJsonArray());
 }

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

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);
 

qt6/gen_qjsonarray.cpp

@@ -8,6 +8,7 @@
 #include <QString>
 #include <QByteArray>
 #include <cstring>
+#include <QVariant>
 #include <qjsonarray.h>
 #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<QVariant**>(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<QVariant**>(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<void*>(_arr);
+	return _out;
+}
+
 ptrdiff_t QJsonArray_size(const QJsonArray* self) {
 	qsizetype _ret = self->size();
 	return static_cast<ptrdiff_t>(_ret);

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))
 }

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);

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<QVariant> list_QList;
+	list_QList.reserve(list.len);
+	QVariant** list_arr = static_cast<QVariant**>(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<QVariant> _ret = self->toList();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	QVariant** _arr = static_cast<QVariant**>(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<void*>(_arr);
+	return _out;
+}
+
 struct miqt_map /* of struct miqt_string to QVariant* */  QVariant_toMap(const QVariant* self) {
 	QMap<QString, QVariant> _ret = self->toMap();
 	// Convert QMap<> from C++ memory to manually-managed C memory

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))

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);