lib/cutego
1
0
Fork 0
mirror of https://github.com/bluszcz/cutego.git synced 2024-09-28 13:15:17 +03:00
Code Issues Projects Releases Packages Wiki Activity

more fixes for js/wasm + fix ldFlags issue + fix minor iOS build issue

Browse source
This commit is contained in:
therecipe 2018-11-17 02:47:23 +01:00
parent c2524f50a5
commit de3f785199
47 changed files with 775 additions and 623 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
core/core.cpp
View file

@ -4002,14 +4002,14 @@ void* QByteArray_Replace2(void* ptr, int pos, int l, char* after, int alen)
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(pos, l, const_cast<const char*>(after), alen));
}
void* QByteArray_SetNum8(void* ptr, double n, char* fo, int prec)
void* QByteArray_SetNum8(void* ptr, double n, char* ff, int prec)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, *fo, prec));
return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, *ff, prec));
}
void* QByteArray_SetNum7(void* ptr, float n, char* fo, int prec)
void* QByteArray_SetNum7(void* ptr, float n, char* ff, int prec)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, *fo, prec));
return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, *ff, prec));
}
void* QByteArray_SetNum(void* ptr, int n, int base)
@ -4072,9 +4072,9 @@ void* QByteArray_QByteArray_FromRawData(char* data, int size)
return new QByteArray(QByteArray::fromRawData(const_cast<const char*>(data), size));
}
void* QByteArray_QByteArray_Number5(double n, char* fo, int prec)
void* QByteArray_QByteArray_Number5(double n, char* ff, int prec)
{
return new QByteArray(QByteArray::number(n, *fo, prec));
return new QByteArray(QByteArray::number(n, *ff, prec));
}
void* QByteArray_QByteArray_Number(int n, int base)
@ -6046,19 +6046,19 @@ void* QDateTime_NewQDateTime2(void* date)
return new QDateTime(*static_cast<QDate*>(date));
}
void* QDateTime_NewQDateTime3(void* date, void* time, long long spec)
void* QDateTime_NewQDateTime3(void* date, void* ti, long long spec)
{
return new QDateTime(*static_cast<QDate*>(date), *static_cast<QTime*>(time), static_cast<Qt::TimeSpec>(spec));
return new QDateTime(*static_cast<QDate*>(date), *static_cast<QTime*>(ti), static_cast<Qt::TimeSpec>(spec));
}
void* QDateTime_NewQDateTime4(void* date, void* time, long long spec, int offsetSeconds)
void* QDateTime_NewQDateTime4(void* date, void* ti, long long spec, int offsetSeconds)
{
return new QDateTime(*static_cast<QDate*>(date), *static_cast<QTime*>(time), static_cast<Qt::TimeSpec>(spec), offsetSeconds);
return new QDateTime(*static_cast<QDate*>(date), *static_cast<QTime*>(ti), static_cast<Qt::TimeSpec>(spec), offsetSeconds);
}
void* QDateTime_NewQDateTime5(void* date, void* time, void* timeZone)
void* QDateTime_NewQDateTime5(void* date, void* ti, void* timeZone)
{
return new QDateTime(*static_cast<QDate*>(date), *static_cast<QTime*>(time), *static_cast<QTimeZone*>(timeZone));
return new QDateTime(*static_cast<QDate*>(date), *static_cast<QTime*>(ti), *static_cast<QTimeZone*>(timeZone));
}
void* QDateTime_NewQDateTime6(void* other)
@ -6096,9 +6096,9 @@ void QDateTime_SetSecsSinceEpoch(void* ptr, long long secs)
static_cast<QDateTime*>(ptr)->setSecsSinceEpoch(secs);
}
void QDateTime_SetTime(void* ptr, void* time)
void QDateTime_SetTime(void* ptr, void* ti)
{
static_cast<QDateTime*>(ptr)->setTime(*static_cast<QTime*>(time));
static_cast<QDateTime*>(ptr)->setTime(*static_cast<QTime*>(ti));
}
void QDateTime_SetTimeSpec(void* ptr, long long spec)
@ -7726,9 +7726,9 @@ void QFileDevice_DestroyQFileDeviceDefault(void* ptr)
}
void* QFileDevice_FileTime(void* ptr, long long time)
void* QFileDevice_FileTime(void* ptr, long long ti)
{
return new QDateTime(static_cast<QFileDevice*>(ptr)->fileTime(static_cast<QFileDevice::FileTime>(time)));
return new QDateTime(static_cast<QFileDevice*>(ptr)->fileTime(static_cast<QFileDevice::FileTime>(ti)));
}
long long QFileDevice_Error(void* ptr)
@ -11691,29 +11691,29 @@ struct QtCore_PackedString QLocale_ToString11(void* ptr, void* dateTime, struct
return ({ QByteArray t336e5f = static_cast<QLocale*>(ptr)->toString(*static_cast<QDateTime*>(dateTime), QString::fromUtf8(format.data, format.len)).toUtf8(); QtCore_PackedString { const_cast<char*>(t336e5f.prepend("WHITESPACE").constData()+10), t336e5f.size()-10 }; });
}
struct QtCore_PackedString QLocale_ToString16(void* ptr, void* time, long long format)
struct QtCore_PackedString QLocale_ToString16(void* ptr, void* ti, long long format)
{
return ({ QByteArray taedd07 = static_cast<QLocale*>(ptr)->toString(*static_cast<QTime*>(time), static_cast<QLocale::FormatType>(format)).toUtf8(); QtCore_PackedString { const_cast<char*>(taedd07.prepend("WHITESPACE").constData()+10), taedd07.size()-10 }; });
return ({ QByteArray tb6230e = static_cast<QLocale*>(ptr)->toString(*static_cast<QTime*>(ti), static_cast<QLocale::FormatType>(format)).toUtf8(); QtCore_PackedString { const_cast<char*>(tb6230e.prepend("WHITESPACE").constData()+10), tb6230e.size()-10 }; });
}
struct QtCore_PackedString QLocale_ToString13(void* ptr, void* time, void* format)
struct QtCore_PackedString QLocale_ToString13(void* ptr, void* ti, void* format)
{
return ({ QByteArray t0bdfb5 = static_cast<QLocale*>(ptr)->toString(*static_cast<QTime*>(time), *static_cast<QStringView*>(format)).toUtf8(); QtCore_PackedString { const_cast<char*>(t0bdfb5.prepend("WHITESPACE").constData()+10), t0bdfb5.size()-10 }; });
return ({ QByteArray t697961 = static_cast<QLocale*>(ptr)->toString(*static_cast<QTime*>(ti), *static_cast<QStringView*>(format)).toUtf8(); QtCore_PackedString { const_cast<char*>(t697961.prepend("WHITESPACE").constData()+10), t697961.size()-10 }; });
}
struct QtCore_PackedString QLocale_ToString10(void* ptr, void* time, struct QtCore_PackedString format)
struct QtCore_PackedString QLocale_ToString10(void* ptr, void* ti, struct QtCore_PackedString format)
{
return ({ QByteArray t30c966 = static_cast<QLocale*>(ptr)->toString(*static_cast<QTime*>(time), QString::fromUtf8(format.data, format.len)).toUtf8(); QtCore_PackedString { const_cast<char*>(t30c966.prepend("WHITESPACE").constData()+10), t30c966.size()-10 }; });
return ({ QByteArray t607af9 = static_cast<QLocale*>(ptr)->toString(*static_cast<QTime*>(ti), QString::fromUtf8(format.data, format.len)).toUtf8(); QtCore_PackedString { const_cast<char*>(t607af9.prepend("WHITESPACE").constData()+10), t607af9.size()-10 }; });
}
struct QtCore_PackedString QLocale_ToString7(void* ptr, double i, char* fo, int prec)
struct QtCore_PackedString QLocale_ToString7(void* ptr, double i, char* ff, int prec)
{
return ({ QByteArray tb2c8bc = static_cast<QLocale*>(ptr)->toString(i, *fo, prec).toUtf8(); QtCore_PackedString { const_cast<char*>(tb2c8bc.prepend("WHITESPACE").constData()+10), tb2c8bc.size()-10 }; });
return ({ QByteArray t07d146 = static_cast<QLocale*>(ptr)->toString(i, *ff, prec).toUtf8(); QtCore_PackedString { const_cast<char*>(t07d146.prepend("WHITESPACE").constData()+10), t07d146.size()-10 }; });
}
struct QtCore_PackedString QLocale_ToString8(void* ptr, float i, char* fo, int prec)
struct QtCore_PackedString QLocale_ToString8(void* ptr, float i, char* ff, int prec)
{
return ({ QByteArray tb2c8bc = static_cast<QLocale*>(ptr)->toString(i, *fo, prec).toUtf8(); QtCore_PackedString { const_cast<char*>(tb2c8bc.prepend("WHITESPACE").constData()+10), tb2c8bc.size()-10 }; });
return ({ QByteArray t07d146 = static_cast<QLocale*>(ptr)->toString(i, *ff, prec).toUtf8(); QtCore_PackedString { const_cast<char*>(t07d146.prepend("WHITESPACE").constData()+10), t07d146.size()-10 }; });
}
struct QtCore_PackedString QLocale_ToString5(void* ptr, int i)
@ -21644,9 +21644,9 @@ void* QThread_NewQThread(void* parent)
}
}
char QThread_Wait(void* ptr, unsigned long time)
char QThread_Wait(void* ptr, unsigned long ti)
{
return static_cast<QThread*>(ptr)->wait(time);
return static_cast<QThread*>(ptr)->wait(ti);
}
int QThread_Exec(void* ptr)
@ -24619,14 +24619,14 @@ void* QWaitCondition_NewQWaitCondition()
return new QWaitCondition();
}
char QWaitCondition_Wait(void* ptr, void* lockedMutex, unsigned long time)
char QWaitCondition_Wait(void* ptr, void* lockedMutex, unsigned long ti)
{
return static_cast<QWaitCondition*>(ptr)->wait(static_cast<QMutex*>(lockedMutex), time);
return static_cast<QWaitCondition*>(ptr)->wait(static_cast<QMutex*>(lockedMutex), ti);
}
char QWaitCondition_Wait2(void* ptr, void* lockedReadWriteLock, unsigned long time)
char QWaitCondition_Wait2(void* ptr, void* lockedReadWriteLock, unsigned long ti)
{
return static_cast<QWaitCondition*>(ptr)->wait(static_cast<QReadWriteLock*>(lockedReadWriteLock), time);
return static_cast<QWaitCondition*>(ptr)->wait(static_cast<QReadWriteLock*>(lockedReadWriteLock), ti);
}
void QWaitCondition_Notify_all(void* ptr)

116
core/core.go
View file

@ -7977,28 +7977,28 @@ func (ptr *QByteArray) Replace2(pos int, l int, after string, alen int) *QByteAr
return nil
}
func (ptr *QByteArray) SetNum8(n float64, fo string, prec int) *QByteArray {
func (ptr *QByteArray) SetNum8(n float64, ff string, prec int) *QByteArray {
if ptr.Pointer() != nil {
var foC *C.char
if fo != "" {
foC = C.CString(fo)
defer C.free(unsafe.Pointer(foC))
var ffC *C.char
if ff != "" {
ffC = C.CString(ff)
defer C.free(unsafe.Pointer(ffC))
}
tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetNum8(ptr.Pointer(), C.double(n), foC, C.int(int32(prec))))
tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetNum8(ptr.Pointer(), C.double(n), ffC, C.int(int32(prec))))
runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
return tmpValue
}
return nil
}
func (ptr *QByteArray) SetNum7(n float32, fo string, prec int) *QByteArray {
func (ptr *QByteArray) SetNum7(n float32, ff string, prec int) *QByteArray {
if ptr.Pointer() != nil {
var foC *C.char
if fo != "" {
foC = C.CString(fo)
defer C.free(unsafe.Pointer(foC))
var ffC *C.char
if ff != "" {
ffC = C.CString(ff)
defer C.free(unsafe.Pointer(ffC))
}
tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetNum7(ptr.Pointer(), C.float(n), foC, C.int(int32(prec))))
tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetNum7(ptr.Pointer(), C.float(n), ffC, C.int(int32(prec))))
runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
return tmpValue
}
@ -8153,24 +8153,24 @@ func (ptr *QByteArray) FromRawData(data string, size int) *QByteArray {
return tmpValue
}
func QByteArray_Number5(n float64, fo string, prec int) *QByteArray {
var foC *C.char
if fo != "" {
foC = C.CString(fo)
defer C.free(unsafe.Pointer(foC))
func QByteArray_Number5(n float64, ff string, prec int) *QByteArray {
var ffC *C.char
if ff != "" {
ffC = C.CString(ff)
defer C.free(unsafe.Pointer(ffC))
}
tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number5(C.double(n), foC, C.int(int32(prec))))
tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number5(C.double(n), ffC, C.int(int32(prec))))
runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
return tmpValue
}
func (ptr *QByteArray) Number5(n float64, fo string, prec int) *QByteArray {
var foC *C.char
if fo != "" {
foC = C.CString(fo)
defer C.free(unsafe.Pointer(foC))
func (ptr *QByteArray) Number5(n float64, ff string, prec int) *QByteArray {
var ffC *C.char
if ff != "" {
ffC = C.CString(ff)
defer C.free(unsafe.Pointer(ffC))
}
tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number5(C.double(n), foC, C.int(int32(prec))))
tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number5(C.double(n), ffC, C.int(int32(prec))))
runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
return tmpValue
}
@ -12680,20 +12680,20 @@ func NewQDateTime2(date QDate_ITF) *QDateTime {
return tmpValue
}
func NewQDateTime3(date QDate_ITF, time QTime_ITF, spec Qt__TimeSpec) *QDateTime {
tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime3(PointerFromQDate(date), PointerFromQTime(time), C.longlong(spec)))
func NewQDateTime3(date QDate_ITF, ti QTime_ITF, spec Qt__TimeSpec) *QDateTime {
tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime3(PointerFromQDate(date), PointerFromQTime(ti), C.longlong(spec)))
runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
return tmpValue
}
func NewQDateTime4(date QDate_ITF, time QTime_ITF, spec Qt__TimeSpec, offsetSeconds int) *QDateTime {
tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime4(PointerFromQDate(date), PointerFromQTime(time), C.longlong(spec), C.int(int32(offsetSeconds))))
func NewQDateTime4(date QDate_ITF, ti QTime_ITF, spec Qt__TimeSpec, offsetSeconds int) *QDateTime {
tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime4(PointerFromQDate(date), PointerFromQTime(ti), C.longlong(spec), C.int(int32(offsetSeconds))))
runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
return tmpValue
}
func NewQDateTime5(date QDate_ITF, time QTime_ITF, timeZone QTimeZone_ITF) *QDateTime {
tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime5(PointerFromQDate(date), PointerFromQTime(time), PointerFromQTimeZone(timeZone)))
func NewQDateTime5(date QDate_ITF, ti QTime_ITF, timeZone QTimeZone_ITF) *QDateTime {
tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime5(PointerFromQDate(date), PointerFromQTime(ti), PointerFromQTimeZone(timeZone)))
runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
return tmpValue
}
@ -12744,9 +12744,9 @@ func (ptr *QDateTime) SetSecsSinceEpoch(secs int64) {
}
}
func (ptr *QDateTime) SetTime(time QTime_ITF) {
func (ptr *QDateTime) SetTime(ti QTime_ITF) {
if ptr.Pointer() != nil {
C.QDateTime_SetTime(ptr.Pointer(), PointerFromQTime(time))
C.QDateTime_SetTime(ptr.Pointer(), PointerFromQTime(ti))
}
}
@ -16545,9 +16545,9 @@ func (ptr *QFileDevice) DestroyQFileDeviceDefault() {
}
}
func (ptr *QFileDevice) FileTime(time QFileDevice__FileTime) *QDateTime {
func (ptr *QFileDevice) FileTime(ti QFileDevice__FileTime) *QDateTime {
if ptr.Pointer() != nil {
tmpValue := NewQDateTimeFromPointer(C.QFileDevice_FileTime(ptr.Pointer(), C.longlong(time)))
tmpValue := NewQDateTimeFromPointer(C.QFileDevice_FileTime(ptr.Pointer(), C.longlong(ti)))
runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
return tmpValue
}
@ -25921,52 +25921,52 @@ func (ptr *QLocale) ToString11(dateTime QDateTime_ITF, format string) string {
return ""
}
func (ptr *QLocale) ToString16(time QTime_ITF, format QLocale__FormatType) string {
func (ptr *QLocale) ToString16(ti QTime_ITF, format QLocale__FormatType) string {
if ptr.Pointer() != nil {
return cGoUnpackString(C.QLocale_ToString16(ptr.Pointer(), PointerFromQTime(time), C.longlong(format)))
return cGoUnpackString(C.QLocale_ToString16(ptr.Pointer(), PointerFromQTime(ti), C.longlong(format)))
}
return ""
}
func (ptr *QLocale) ToString13(time QTime_ITF, format QStringView_ITF) string {
func (ptr *QLocale) ToString13(ti QTime_ITF, format QStringView_ITF) string {
if ptr.Pointer() != nil {
return cGoUnpackString(C.QLocale_ToString13(ptr.Pointer(), PointerFromQTime(time), PointerFromQStringView(format)))
return cGoUnpackString(C.QLocale_ToString13(ptr.Pointer(), PointerFromQTime(ti), PointerFromQStringView(format)))
}
return ""
}
func (ptr *QLocale) ToString10(time QTime_ITF, format string) string {
func (ptr *QLocale) ToString10(ti QTime_ITF, format string) string {
if ptr.Pointer() != nil {
var formatC *C.char
if format != "" {
formatC = C.CString(format)
defer C.free(unsafe.Pointer(formatC))
}
return cGoUnpackString(C.QLocale_ToString10(ptr.Pointer(), PointerFromQTime(time), C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
return cGoUnpackString(C.QLocale_ToString10(ptr.Pointer(), PointerFromQTime(ti), C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
}
return ""
}
func (ptr *QLocale) ToString7(i float64, fo string, prec int) string {
func (ptr *QLocale) ToString7(i float64, ff string, prec int) string {
if ptr.Pointer() != nil {
var foC *C.char
if fo != "" {
foC = C.CString(fo)
defer C.free(unsafe.Pointer(foC))
var ffC *C.char
if ff != "" {
ffC = C.CString(ff)
defer C.free(unsafe.Pointer(ffC))
}
return cGoUnpackString(C.QLocale_ToString7(ptr.Pointer(), C.double(i), foC, C.int(int32(prec))))
return cGoUnpackString(C.QLocale_ToString7(ptr.Pointer(), C.double(i), ffC, C.int(int32(prec))))
}
return ""
}
func (ptr *QLocale) ToString8(i float32, fo string, prec int) string {
func (ptr *QLocale) ToString8(i float32, ff string, prec int) string {
if ptr.Pointer() != nil {
var foC *C.char
if fo != "" {
foC = C.CString(fo)
defer C.free(unsafe.Pointer(foC))
var ffC *C.char
if ff != "" {
ffC = C.CString(ff)
defer C.free(unsafe.Pointer(ffC))
}
return cGoUnpackString(C.QLocale_ToString8(ptr.Pointer(), C.float(i), foC, C.int(int32(prec))))
return cGoUnpackString(C.QLocale_ToString8(ptr.Pointer(), C.float(i), ffC, C.int(int32(prec))))
}
return ""
}
@ -45061,9 +45061,9 @@ func NewQThread(parent QObject_ITF) *QThread {
return tmpValue
}
func (ptr *QThread) Wait(time uint) bool {
func (ptr *QThread) Wait(ti uint) bool {
if ptr.Pointer() != nil {
return int8(C.QThread_Wait(ptr.Pointer(), C.ulong(uint32(time)))) != 0
return int8(C.QThread_Wait(ptr.Pointer(), C.ulong(uint32(ti)))) != 0
}
return false
}
@ -51715,16 +51715,16 @@ func NewQWaitCondition() *QWaitCondition {
return tmpValue
}
func (ptr *QWaitCondition) Wait(lockedMutex QMutex_ITF, time uint) bool {
func (ptr *QWaitCondition) Wait(lockedMutex QMutex_ITF, ti uint) bool {
if ptr.Pointer() != nil {
return int8(C.QWaitCondition_Wait(ptr.Pointer(), PointerFromQMutex(lockedMutex), C.ulong(uint32(time)))) != 0
return int8(C.QWaitCondition_Wait(ptr.Pointer(), PointerFromQMutex(lockedMutex), C.ulong(uint32(ti)))) != 0
}
return false
}
func (ptr *QWaitCondition) Wait2(lockedReadWriteLock QReadWriteLock_ITF, time uint) bool {
func (ptr *QWaitCondition) Wait2(lockedReadWriteLock QReadWriteLock_ITF, ti uint) bool {
if ptr.Pointer() != nil {
return int8(C.QWaitCondition_Wait2(ptr.Pointer(), PointerFromQReadWriteLock(lockedReadWriteLock), C.ulong(uint32(time)))) != 0
return int8(C.QWaitCondition_Wait2(ptr.Pointer(), PointerFromQReadWriteLock(lockedReadWriteLock), C.ulong(uint32(ti)))) != 0
}
return false
}

32
core/core.h
View file

@ -530,8 +530,8 @@ void* QByteArray_Replace7(void* ptr, char* before, int bsize, char* after, int a
void* QByteArray_Replace(void* ptr, int pos, int l, void* after);
void* QByteArray_Replace3(void* ptr, int pos, int l, char* after);
void* QByteArray_Replace2(void* ptr, int pos, int l, char* after, int alen);
void* QByteArray_SetNum8(void* ptr, double n, char* fo, int prec);
void* QByteArray_SetNum7(void* ptr, float n, char* fo, int prec);
void* QByteArray_SetNum8(void* ptr, double n, char* ff, int prec);
void* QByteArray_SetNum7(void* ptr, float n, char* ff, int prec);
void* QByteArray_SetNum(void* ptr, int n, int base);
void* QByteArray_SetNum5(void* ptr, long long n, int base);
void* QByteArray_SetNum6(void* ptr, unsigned long long n, int base);
@ -544,7 +544,7 @@ void* QByteArray_QByteArray_FromBase642(void* base64, long long options);
void* QByteArray_QByteArray_FromHex(void* hexEncoded);
void* QByteArray_QByteArray_FromPercentEncoding(void* input, char* percent);
void* QByteArray_QByteArray_FromRawData(char* data, int size);
void* QByteArray_QByteArray_Number5(double n, char* fo, int prec);
void* QByteArray_QByteArray_Number5(double n, char* ff, int prec);
void* QByteArray_QByteArray_Number(int n, int base);
void* QByteArray_QByteArray_Number3(long long n, int base);
void* QByteArray_QByteArray_Number4(unsigned long long n, int base);
@ -924,9 +924,9 @@ void* QDateTime_QDateTime_FromString2(struct QtCore_PackedString stri, struct Qt
void* QDateTime_NewQDateTime();
void* QDateTime_NewQDateTime7(void* other);
void* QDateTime_NewQDateTime2(void* date);
void* QDateTime_NewQDateTime3(void* date, void* time, long long spec);
void* QDateTime_NewQDateTime4(void* date, void* time, long long spec, int offsetSeconds);
void* QDateTime_NewQDateTime5(void* date, void* time, void* timeZone);
void* QDateTime_NewQDateTime3(void* date, void* ti, long long spec);
void* QDateTime_NewQDateTime4(void* date, void* ti, long long spec, int offsetSeconds);
void* QDateTime_NewQDateTime5(void* date, void* ti, void* timeZone);
void* QDateTime_NewQDateTime6(void* other);
long long QDateTime_QDateTime_CurrentMSecsSinceEpoch();
long long QDateTime_QDateTime_CurrentSecsSinceEpoch();
@ -934,7 +934,7 @@ void QDateTime_SetDate(void* ptr, void* date);
void QDateTime_SetMSecsSinceEpoch(void* ptr, long long msecs);
void QDateTime_SetOffsetFromUtc(void* ptr, int offsetSeconds);
void QDateTime_SetSecsSinceEpoch(void* ptr, long long secs);
void QDateTime_SetTime(void* ptr, void* time);
void QDateTime_SetTime(void* ptr, void* ti);
void QDateTime_SetTimeSpec(void* ptr, long long spec);
void QDateTime_SetTimeZone(void* ptr, void* toZone);
void QDateTime_Swap(void* ptr, void* other);
@ -1192,7 +1192,7 @@ struct QtCore_PackedString QFileDevice_Map(void* ptr, long long offset, long lon
void QFileDevice_UnsetError(void* ptr);
void QFileDevice_DestroyQFileDevice(void* ptr);
void QFileDevice_DestroyQFileDeviceDefault(void* ptr);
void* QFileDevice_FileTime(void* ptr, long long time);
void* QFileDevice_FileTime(void* ptr, long long ti);
long long QFileDevice_Error(void* ptr);
long long QFileDevice_Permissions(void* ptr);
long long QFileDevice_PermissionsDefault(void* ptr);
@ -1817,11 +1817,11 @@ struct QtCore_PackedString QLocale_ToString9(void* ptr, void* date, struct QtCor
struct QtCore_PackedString QLocale_ToString17(void* ptr, void* dateTime, long long format);
struct QtCore_PackedString QLocale_ToString14(void* ptr, void* dateTime, void* format);
struct QtCore_PackedString QLocale_ToString11(void* ptr, void* dateTime, struct QtCore_PackedString format);
struct QtCore_PackedString QLocale_ToString16(void* ptr, void* time, long long format);
struct QtCore_PackedString QLocale_ToString13(void* ptr, void* time, void* format);
struct QtCore_PackedString QLocale_ToString10(void* ptr, void* time, struct QtCore_PackedString format);
struct QtCore_PackedString QLocale_ToString7(void* ptr, double i, char* fo, int prec);
struct QtCore_PackedString QLocale_ToString8(void* ptr, float i, char* fo, int prec);
struct QtCore_PackedString QLocale_ToString16(void* ptr, void* ti, long long format);
struct QtCore_PackedString QLocale_ToString13(void* ptr, void* ti, void* format);
struct QtCore_PackedString QLocale_ToString10(void* ptr, void* ti, struct QtCore_PackedString format);
struct QtCore_PackedString QLocale_ToString7(void* ptr, double i, char* ff, int prec);
struct QtCore_PackedString QLocale_ToString8(void* ptr, float i, char* ff, int prec);
struct QtCore_PackedString QLocale_ToString5(void* ptr, int i);
struct QtCore_PackedString QLocale_ToString(void* ptr, long long i);
struct QtCore_PackedString QLocale_ToString2(void* ptr, unsigned long long i);
@ -3274,7 +3274,7 @@ long long QTextStream_Pos(void* ptr);
struct QtCore_PackedString QThread_QThread_TrUtf8(char* s, char* c, int n);
void* QThread_QThread_CurrentThread();
void* QThread_NewQThread(void* parent);
char QThread_Wait(void* ptr, unsigned long time);
char QThread_Wait(void* ptr, unsigned long ti);
int QThread_Exec(void* ptr);
int QThread_QThread_IdealThreadCount();
void QThread_Exit(void* ptr, int returnCode);
@ -3795,8 +3795,8 @@ int QVersionNumber___segments_atList(void* ptr, int i);
void QVersionNumber___segments_setList(void* ptr, int i);
void* QVersionNumber___segments_newList(void* ptr);
void* QWaitCondition_NewQWaitCondition();
char QWaitCondition_Wait(void* ptr, void* lockedMutex, unsigned long time);
char QWaitCondition_Wait2(void* ptr, void* lockedReadWriteLock, unsigned long time);
char QWaitCondition_Wait(void* ptr, void* lockedMutex, unsigned long ti);
char QWaitCondition_Wait2(void* ptr, void* lockedReadWriteLock, unsigned long ti);
void QWaitCondition_Notify_all(void* ptr);
void QWaitCondition_Notify_one(void* ptr);
void QWaitCondition_WakeAll(void* ptr);

48
gui/gui.cpp
View file

@ -5417,9 +5417,9 @@ char QFont_FixedPitch(void* ptr)
return static_cast<QFont*>(ptr)->fixedPitch();
}
char QFont_IsCopyOf(void* ptr, void* fo)
char QFont_IsCopyOf(void* ptr, void* ff)
{
return static_cast<QFont*>(ptr)->isCopyOf(*static_cast<QFont*>(fo));
return static_cast<QFont*>(ptr)->isCopyOf(*static_cast<QFont*>(ff));
}
char QFont_Italic(void* ptr)
@ -48589,9 +48589,9 @@ void QOpenGLFunctions_4_1_Compatibility_GlDepthMask5(void* ptr, char flag)
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_1_Compatibility_GlDepthRangef5(void* ptr, float n, float fo)
void QOpenGLFunctions_4_1_Compatibility_GlDepthRangef5(void* ptr, float n, float ff)
{
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDepthRangef(n, fo);
static_cast<QOpenGLFunctions_4_1_Compatibility*>(ptr)->glDepthRangef(n, ff);
}
void QOpenGLFunctions_4_1_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
@ -51873,9 +51873,9 @@ void QOpenGLFunctions_4_1_Core_GlDepthMask5(void* ptr, char flag)
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_1_Core_GlDepthRangef5(void* ptr, float n, float fo)
void QOpenGLFunctions_4_1_Core_GlDepthRangef5(void* ptr, float n, float ff)
{
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDepthRangef(n, fo);
static_cast<QOpenGLFunctions_4_1_Core*>(ptr)->glDepthRangef(n, ff);
}
void QOpenGLFunctions_4_1_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
@ -53987,9 +53987,9 @@ void QOpenGLFunctions_4_2_Compatibility_GlDepthMask5(void* ptr, char flag)
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_2_Compatibility_GlDepthRangef5(void* ptr, float n, float fo)
void QOpenGLFunctions_4_2_Compatibility_GlDepthRangef5(void* ptr, float n, float ff)
{
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDepthRangef(n, fo);
static_cast<QOpenGLFunctions_4_2_Compatibility*>(ptr)->glDepthRangef(n, ff);
}
void QOpenGLFunctions_4_2_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
@ -57331,9 +57331,9 @@ void QOpenGLFunctions_4_2_Core_GlDepthMask5(void* ptr, char flag)
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_2_Core_GlDepthRangef5(void* ptr, float n, float fo)
void QOpenGLFunctions_4_2_Core_GlDepthRangef5(void* ptr, float n, float ff)
{
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDepthRangef(n, fo);
static_cast<QOpenGLFunctions_4_2_Core*>(ptr)->glDepthRangef(n, ff);
}
void QOpenGLFunctions_4_2_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
@ -59510,9 +59510,9 @@ void QOpenGLFunctions_4_3_Compatibility_GlDepthMask5(void* ptr, char flag)
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_3_Compatibility_GlDepthRangef5(void* ptr, float n, float fo)
void QOpenGLFunctions_4_3_Compatibility_GlDepthRangef5(void* ptr, float n, float ff)
{
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDepthRangef(n, fo);
static_cast<QOpenGLFunctions_4_3_Compatibility*>(ptr)->glDepthRangef(n, ff);
}
void QOpenGLFunctions_4_3_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
@ -62969,9 +62969,9 @@ void QOpenGLFunctions_4_3_Core_GlDepthMask5(void* ptr, char flag)
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_3_Core_GlDepthRangef5(void* ptr, float n, float fo)
void QOpenGLFunctions_4_3_Core_GlDepthRangef5(void* ptr, float n, float ff)
{
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDepthRangef(n, fo);
static_cast<QOpenGLFunctions_4_3_Core*>(ptr)->glDepthRangef(n, ff);
}
void QOpenGLFunctions_4_3_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
@ -65288,9 +65288,9 @@ void QOpenGLFunctions_4_4_Compatibility_GlDepthMask5(void* ptr, char flag)
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_4_Compatibility_GlDepthRangef5(void* ptr, float n, float fo)
void QOpenGLFunctions_4_4_Compatibility_GlDepthRangef5(void* ptr, float n, float ff)
{
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDepthRangef(n, fo);
static_cast<QOpenGLFunctions_4_4_Compatibility*>(ptr)->glDepthRangef(n, ff);
}
void QOpenGLFunctions_4_4_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
@ -68767,9 +68767,9 @@ void QOpenGLFunctions_4_4_Core_GlDepthMask5(void* ptr, char flag)
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_4_Core_GlDepthRangef5(void* ptr, float n, float fo)
void QOpenGLFunctions_4_4_Core_GlDepthRangef5(void* ptr, float n, float ff)
{
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDepthRangef(n, fo);
static_cast<QOpenGLFunctions_4_4_Core*>(ptr)->glDepthRangef(n, ff);
}
void QOpenGLFunctions_4_4_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
@ -71306,9 +71306,9 @@ void QOpenGLFunctions_4_5_Compatibility_GlDepthMask5(void* ptr, char flag)
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_5_Compatibility_GlDepthRangef5(void* ptr, float n, float fo)
void QOpenGLFunctions_4_5_Compatibility_GlDepthRangef5(void* ptr, float n, float ff)
{
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDepthRangef(n, fo);
static_cast<QOpenGLFunctions_4_5_Compatibility*>(ptr)->glDepthRangef(n, ff);
}
void QOpenGLFunctions_4_5_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
@ -75300,9 +75300,9 @@ void QOpenGLFunctions_4_5_Core_GlDepthMask5(void* ptr, char flag)
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDepthMask(flag != 0);
}
void QOpenGLFunctions_4_5_Core_GlDepthRangef5(void* ptr, float n, float fo)
void QOpenGLFunctions_4_5_Core_GlDepthRangef5(void* ptr, float n, float ff)
{
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDepthRangef(n, fo);
static_cast<QOpenGLFunctions_4_5_Core*>(ptr)->glDepthRangef(n, ff);
}
void QOpenGLFunctions_4_5_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader)
@ -93082,9 +93082,9 @@ void* QTextDocument_Object(void* ptr, int objectIndex)
return static_cast<QTextDocument*>(ptr)->object(objectIndex);
}
void* QTextDocument_ObjectForFormat(void* ptr, void* fo)
void* QTextDocument_ObjectForFormat(void* ptr, void* ff)
{
return static_cast<QTextDocument*>(ptr)->objectForFormat(*static_cast<QTextFormat*>(fo));
return static_cast<QTextDocument*>(ptr)->objectForFormat(*static_cast<QTextFormat*>(ff));
}
void* QTextDocument_DefaultTextOption(void* ptr)

48
gui/gui.go
View file

@ -12177,9 +12177,9 @@ func (ptr *QFont) FixedPitch() bool {
return false
}
func (ptr *QFont) IsCopyOf(fo QFont_ITF) bool {
func (ptr *QFont) IsCopyOf(ff QFont_ITF) bool {
if ptr.Pointer() != nil {
return int8(C.QFont_IsCopyOf(ptr.Pointer(), PointerFromQFont(fo))) != 0
return int8(C.QFont_IsCopyOf(ptr.Pointer(), PointerFromQFont(ff))) != 0
}
return false
}
@ -74317,9 +74317,9 @@ func (ptr *QOpenGLFunctions_4_1_Compatibility) GlDepthMask5(flag bool) {
}
}
func (ptr *QOpenGLFunctions_4_1_Compatibility) GlDepthRangef5(n float32, fo float32) {
func (ptr *QOpenGLFunctions_4_1_Compatibility) GlDepthRangef5(n float32, ff float32) {
if ptr.Pointer() != nil {
C.QOpenGLFunctions_4_1_Compatibility_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(fo))
C.QOpenGLFunctions_4_1_Compatibility_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(ff))
}
}
@ -78449,9 +78449,9 @@ func (ptr *QOpenGLFunctions_4_1_Core) GlDepthMask5(flag bool) {
}
}
func (ptr *QOpenGLFunctions_4_1_Core) GlDepthRangef5(n float32, fo float32) {
func (ptr *QOpenGLFunctions_4_1_Core) GlDepthRangef5(n float32, ff float32) {
if ptr.Pointer() != nil {
C.QOpenGLFunctions_4_1_Core_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(fo))
C.QOpenGLFunctions_4_1_Core_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(ff))
}
}
@ -81166,9 +81166,9 @@ func (ptr *QOpenGLFunctions_4_2_Compatibility) GlDepthMask5(flag bool) {
}
}
func (ptr *QOpenGLFunctions_4_2_Compatibility) GlDepthRangef5(n float32, fo float32) {
func (ptr *QOpenGLFunctions_4_2_Compatibility) GlDepthRangef5(n float32, ff float32) {
if ptr.Pointer() != nil {
C.QOpenGLFunctions_4_2_Compatibility_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(fo))
C.QOpenGLFunctions_4_2_Compatibility_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(ff))
}
}
@ -85370,9 +85370,9 @@ func (ptr *QOpenGLFunctions_4_2_Core) GlDepthMask5(flag bool) {
}
}
func (ptr *QOpenGLFunctions_4_2_Core) GlDepthRangef5(n float32, fo float32) {
func (ptr *QOpenGLFunctions_4_2_Core) GlDepthRangef5(n float32, ff float32) {
if ptr.Pointer() != nil {
C.QOpenGLFunctions_4_2_Core_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(fo))
C.QOpenGLFunctions_4_2_Core_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(ff))
}
}
@ -88165,9 +88165,9 @@ func (ptr *QOpenGLFunctions_4_3_Compatibility) GlDepthMask5(flag bool) {
}
}
func (ptr *QOpenGLFunctions_4_3_Compatibility) GlDepthRangef5(n float32, fo float32) {
func (ptr *QOpenGLFunctions_4_3_Compatibility) GlDepthRangef5(n float32, ff float32) {
if ptr.Pointer() != nil {
C.QOpenGLFunctions_4_3_Compatibility_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(fo))
C.QOpenGLFunctions_4_3_Compatibility_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(ff))
}
}
@ -92507,9 +92507,9 @@ func (ptr *QOpenGLFunctions_4_3_Core) GlDepthMask5(flag bool) {
}
}
func (ptr *QOpenGLFunctions_4_3_Core) GlDepthRangef5(n float32, fo float32) {
func (ptr *QOpenGLFunctions_4_3_Core) GlDepthRangef5(n float32, ff float32) {
if ptr.Pointer() != nil {
C.QOpenGLFunctions_4_3_Core_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(fo))
C.QOpenGLFunctions_4_3_Core_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(ff))
}
}
@ -95470,9 +95470,9 @@ func (ptr *QOpenGLFunctions_4_4_Compatibility) GlDepthMask5(flag bool) {
}
}
func (ptr *QOpenGLFunctions_4_4_Compatibility) GlDepthRangef5(n float32, fo float32) {
func (ptr *QOpenGLFunctions_4_4_Compatibility) GlDepthRangef5(n float32, ff float32) {
if ptr.Pointer() != nil {
C.QOpenGLFunctions_4_4_Compatibility_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(fo))
C.QOpenGLFunctions_4_4_Compatibility_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(ff))
}
}
@ -99836,9 +99836,9 @@ func (ptr *QOpenGLFunctions_4_4_Core) GlDepthMask5(flag bool) {
}
}
func (ptr *QOpenGLFunctions_4_4_Core) GlDepthRangef5(n float32, fo float32) {
func (ptr *QOpenGLFunctions_4_4_Core) GlDepthRangef5(n float32, ff float32) {
if ptr.Pointer() != nil {
C.QOpenGLFunctions_4_4_Core_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(fo))
C.QOpenGLFunctions_4_4_Core_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(ff))
}
}
@ -103092,9 +103092,9 @@ func (ptr *QOpenGLFunctions_4_5_Compatibility) GlDepthMask5(flag bool) {
}
}
func (ptr *QOpenGLFunctions_4_5_Compatibility) GlDepthRangef5(n float32, fo float32) {
func (ptr *QOpenGLFunctions_4_5_Compatibility) GlDepthRangef5(n float32, ff float32) {
if ptr.Pointer() != nil {
C.QOpenGLFunctions_4_5_Compatibility_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(fo))
C.QOpenGLFunctions_4_5_Compatibility_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(ff))
}
}
@ -108085,9 +108085,9 @@ func (ptr *QOpenGLFunctions_4_5_Core) GlDepthMask5(flag bool) {
}
}
func (ptr *QOpenGLFunctions_4_5_Core) GlDepthRangef5(n float32, fo float32) {
func (ptr *QOpenGLFunctions_4_5_Core) GlDepthRangef5(n float32, ff float32) {
if ptr.Pointer() != nil {
C.QOpenGLFunctions_4_5_Core_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(fo))
C.QOpenGLFunctions_4_5_Core_GlDepthRangef5(ptr.Pointer(), C.float(n), C.float(ff))
}
}
@ -139708,9 +139708,9 @@ func (ptr *QTextDocument) Object(objectIndex int) *QTextObject {
return nil
}
func (ptr *QTextDocument) ObjectForFormat(fo QTextFormat_ITF) *QTextObject {
func (ptr *QTextDocument) ObjectForFormat(ff QTextFormat_ITF) *QTextObject {
if ptr.Pointer() != nil {
tmpValue := NewQTextObjectFromPointer(C.QTextDocument_ObjectForFormat(ptr.Pointer(), PointerFromQTextFormat(fo)))
tmpValue := NewQTextObjectFromPointer(C.QTextDocument_ObjectForFormat(ptr.Pointer(), PointerFromQTextFormat(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}

24
gui/gui.h
View file

@ -837,7 +837,7 @@ struct QtGui_PackedString QFont_ToString(void* ptr);
char QFont_Bold(void* ptr);
char QFont_ExactMatch(void* ptr);
char QFont_FixedPitch(void* ptr);
char QFont_IsCopyOf(void* ptr, void* fo);
char QFont_IsCopyOf(void* ptr, void* ff);
char QFont_Italic(void* ptr);
char QFont_Kerning(void* ptr);
char QFont_Overline(void* ptr);
@ -9149,7 +9149,7 @@ void QOpenGLFunctions_4_1_Compatibility_GlDeleteTransformFeedbacks5(void* ptr, i
void QOpenGLFunctions_4_1_Compatibility_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays);
void QOpenGLFunctions_4_1_Compatibility_GlDepthFunc5(void* ptr, unsigned int fu);
void QOpenGLFunctions_4_1_Compatibility_GlDepthMask5(void* ptr, char flag);
void QOpenGLFunctions_4_1_Compatibility_GlDepthRangef5(void* ptr, float n, float fo);
void QOpenGLFunctions_4_1_Compatibility_GlDepthRangef5(void* ptr, float n, float ff);
void QOpenGLFunctions_4_1_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader);
void QOpenGLFunctions_4_1_Compatibility_GlDisable5(void* ptr, unsigned int cap);
void QOpenGLFunctions_4_1_Compatibility_GlDisableClientState5(void* ptr, unsigned int array);
@ -9804,7 +9804,7 @@ void QOpenGLFunctions_4_1_Core_GlDeleteTransformFeedbacks5(void* ptr, int n, uns
void QOpenGLFunctions_4_1_Core_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays);
void QOpenGLFunctions_4_1_Core_GlDepthFunc5(void* ptr, unsigned int fu);
void QOpenGLFunctions_4_1_Core_GlDepthMask5(void* ptr, char flag);
void QOpenGLFunctions_4_1_Core_GlDepthRangef5(void* ptr, float n, float fo);
void QOpenGLFunctions_4_1_Core_GlDepthRangef5(void* ptr, float n, float ff);
void QOpenGLFunctions_4_1_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader);
void QOpenGLFunctions_4_1_Core_GlDisable5(void* ptr, unsigned int cap);
void QOpenGLFunctions_4_1_Core_GlDisableVertexAttribArray5(void* ptr, unsigned int index);
@ -10225,7 +10225,7 @@ void QOpenGLFunctions_4_2_Compatibility_GlDeleteTransformFeedbacks5(void* ptr, i
void QOpenGLFunctions_4_2_Compatibility_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays);
void QOpenGLFunctions_4_2_Compatibility_GlDepthFunc5(void* ptr, unsigned int fu);
void QOpenGLFunctions_4_2_Compatibility_GlDepthMask5(void* ptr, char flag);
void QOpenGLFunctions_4_2_Compatibility_GlDepthRangef5(void* ptr, float n, float fo);
void QOpenGLFunctions_4_2_Compatibility_GlDepthRangef5(void* ptr, float n, float ff);
void QOpenGLFunctions_4_2_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader);
void QOpenGLFunctions_4_2_Compatibility_GlDisable5(void* ptr, unsigned int cap);
void QOpenGLFunctions_4_2_Compatibility_GlDisableClientState5(void* ptr, unsigned int array);
@ -10892,7 +10892,7 @@ void QOpenGLFunctions_4_2_Core_GlDeleteTransformFeedbacks5(void* ptr, int n, uns
void QOpenGLFunctions_4_2_Core_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays);
void QOpenGLFunctions_4_2_Core_GlDepthFunc5(void* ptr, unsigned int fu);
void QOpenGLFunctions_4_2_Core_GlDepthMask5(void* ptr, char flag);
void QOpenGLFunctions_4_2_Core_GlDepthRangef5(void* ptr, float n, float fo);
void QOpenGLFunctions_4_2_Core_GlDepthRangef5(void* ptr, float n, float ff);
void QOpenGLFunctions_4_2_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader);
void QOpenGLFunctions_4_2_Core_GlDisable5(void* ptr, unsigned int cap);
void QOpenGLFunctions_4_2_Core_GlDisableVertexAttribArray5(void* ptr, unsigned int index);
@ -11326,7 +11326,7 @@ void QOpenGLFunctions_4_3_Compatibility_GlDeleteTransformFeedbacks5(void* ptr, i
void QOpenGLFunctions_4_3_Compatibility_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays);
void QOpenGLFunctions_4_3_Compatibility_GlDepthFunc5(void* ptr, unsigned int fu);
void QOpenGLFunctions_4_3_Compatibility_GlDepthMask5(void* ptr, char flag);
void QOpenGLFunctions_4_3_Compatibility_GlDepthRangef5(void* ptr, float n, float fo);
void QOpenGLFunctions_4_3_Compatibility_GlDepthRangef5(void* ptr, float n, float ff);
void QOpenGLFunctions_4_3_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader);
void QOpenGLFunctions_4_3_Compatibility_GlDisable5(void* ptr, unsigned int cap);
void QOpenGLFunctions_4_3_Compatibility_GlDisableClientState5(void* ptr, unsigned int array);
@ -12016,7 +12016,7 @@ void QOpenGLFunctions_4_3_Core_GlDeleteTransformFeedbacks5(void* ptr, int n, uns
void QOpenGLFunctions_4_3_Core_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays);
void QOpenGLFunctions_4_3_Core_GlDepthFunc5(void* ptr, unsigned int fu);
void QOpenGLFunctions_4_3_Core_GlDepthMask5(void* ptr, char flag);
void QOpenGLFunctions_4_3_Core_GlDepthRangef5(void* ptr, float n, float fo);
void QOpenGLFunctions_4_3_Core_GlDepthRangef5(void* ptr, float n, float ff);
void QOpenGLFunctions_4_3_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader);
void QOpenGLFunctions_4_3_Core_GlDisable5(void* ptr, unsigned int cap);
void QOpenGLFunctions_4_3_Core_GlDisableVertexAttribArray5(void* ptr, unsigned int index);
@ -12478,7 +12478,7 @@ void QOpenGLFunctions_4_4_Compatibility_GlDeleteTransformFeedbacks5(void* ptr, i
void QOpenGLFunctions_4_4_Compatibility_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays);
void QOpenGLFunctions_4_4_Compatibility_GlDepthFunc5(void* ptr, unsigned int fu);
void QOpenGLFunctions_4_4_Compatibility_GlDepthMask5(void* ptr, char flag);
void QOpenGLFunctions_4_4_Compatibility_GlDepthRangef5(void* ptr, float n, float fo);
void QOpenGLFunctions_4_4_Compatibility_GlDepthRangef5(void* ptr, float n, float ff);
void QOpenGLFunctions_4_4_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader);
void QOpenGLFunctions_4_4_Compatibility_GlDisable5(void* ptr, unsigned int cap);
void QOpenGLFunctions_4_4_Compatibility_GlDisableClientState5(void* ptr, unsigned int array);
@ -13172,7 +13172,7 @@ void QOpenGLFunctions_4_4_Core_GlDeleteTransformFeedbacks5(void* ptr, int n, uns
void QOpenGLFunctions_4_4_Core_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays);
void QOpenGLFunctions_4_4_Core_GlDepthFunc5(void* ptr, unsigned int fu);
void QOpenGLFunctions_4_4_Core_GlDepthMask5(void* ptr, char flag);
void QOpenGLFunctions_4_4_Core_GlDepthRangef5(void* ptr, float n, float fo);
void QOpenGLFunctions_4_4_Core_GlDepthRangef5(void* ptr, float n, float ff);
void QOpenGLFunctions_4_4_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader);
void QOpenGLFunctions_4_4_Core_GlDisable5(void* ptr, unsigned int cap);
void QOpenGLFunctions_4_4_Core_GlDisableVertexAttribArray5(void* ptr, unsigned int index);
@ -13678,7 +13678,7 @@ void QOpenGLFunctions_4_5_Compatibility_GlDeleteTransformFeedbacks5(void* ptr, i
void QOpenGLFunctions_4_5_Compatibility_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays);
void QOpenGLFunctions_4_5_Compatibility_GlDepthFunc5(void* ptr, unsigned int fu);
void QOpenGLFunctions_4_5_Compatibility_GlDepthMask5(void* ptr, char flag);
void QOpenGLFunctions_4_5_Compatibility_GlDepthRangef5(void* ptr, float n, float fo);
void QOpenGLFunctions_4_5_Compatibility_GlDepthRangef5(void* ptr, float n, float ff);
void QOpenGLFunctions_4_5_Compatibility_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader);
void QOpenGLFunctions_4_5_Compatibility_GlDisable5(void* ptr, unsigned int cap);
void QOpenGLFunctions_4_5_Compatibility_GlDisableClientState5(void* ptr, unsigned int array);
@ -14475,7 +14475,7 @@ void QOpenGLFunctions_4_5_Core_GlDeleteTransformFeedbacks5(void* ptr, int n, uns
void QOpenGLFunctions_4_5_Core_GlDeleteVertexArrays5(void* ptr, int n, unsigned int arrays);
void QOpenGLFunctions_4_5_Core_GlDepthFunc5(void* ptr, unsigned int fu);
void QOpenGLFunctions_4_5_Core_GlDepthMask5(void* ptr, char flag);
void QOpenGLFunctions_4_5_Core_GlDepthRangef5(void* ptr, float n, float fo);
void QOpenGLFunctions_4_5_Core_GlDepthRangef5(void* ptr, float n, float ff);
void QOpenGLFunctions_4_5_Core_GlDetachShader5(void* ptr, unsigned int program, unsigned int shader);
void QOpenGLFunctions_4_5_Core_GlDisable5(void* ptr, unsigned int cap);
void QOpenGLFunctions_4_5_Core_GlDisableVertexArrayAttrib5(void* ptr, unsigned int vaobj, unsigned int index);
@ -17485,7 +17485,7 @@ void* QTextDocument_Find2(void* ptr, struct QtGui_PackedString subString, int po
void* QTextDocument_Clone(void* ptr, void* parent);
void* QTextDocument_RootFrame(void* ptr);
void* QTextDocument_Object(void* ptr, int objectIndex);
void* QTextDocument_ObjectForFormat(void* ptr, void* fo);
void* QTextDocument_ObjectForFormat(void* ptr, void* ff);
void* QTextDocument_DefaultTextOption(void* ptr);
void* QTextDocument_BaseUrl(void* ptr);
void* QTextDocument_Resource(void* ptr, int ty, void* name);

4
internal/binding/converter/body_input_go.go
View file

@ -164,7 +164,11 @@ func GoInputParametersForCallback(function *parser.Function) string {
if function.Name == "readData" && strings.HasPrefix(cgoOutput(parameter.Name, parameter.Value, function, parameter.PureGoType), "cGoUnpackString") {
input[i] = "&retS"
} else if strings.Contains(goType(function, parameter.Value, parameter.PureGoType), "*bool") {
if function.SignalMode != parser.CALLBACK {
input[i] = "nil" //TODO: make *bool usable from pure js
} else {
input[i] = fmt.Sprintf("&%vR", parser.CleanName(parameter.Name, parameter.Value))
}
} else {
input[i] = cgoOutput(parameter.Name, parameter.Value, function, parameter.PureGoType)
}

4
internal/binding/converter/body_output_cpp.go
View file

@ -98,12 +98,12 @@ func CppOutputTemplateJS(function *parser.Function) string {
}
switch {
case len(out) == 0:
return "void"
case isClass(out) || parser.IsPackedList(out) || parser.IsPackedMap(out) || cppType(function, function.Output) == "void*" || cppType(function, function.Output) == "uintptr_t":
return "uintptr_t"
case isEnum(function.ClassName(), out) && (function.BoundByEmscripten || function.SignalMode == parser.CALLBACK):
return "long"
case len(out) == 0:
return "void"
default:
return out
}

4
internal/binding/converter/header.go
View file

@ -184,9 +184,13 @@ func GoHeaderInput(f *parser.Function) string {
} else {
fmt.Fprintf(bb, ", %vP *js.Object", parser.CleanName(p.Name, p.Value))
}
} else {
if f.FakeForJSCallback {
fmt.Fprintf(bb, ", %v *js.Object", parser.CleanName(p.Name, p.Value))
} else {
fmt.Fprintf(bb, ", %v uintptr", parser.CleanName(p.Name, p.Value))
}
}
} else {
if parser.IsPackedList(cv) || parser.IsPackedMap(cv) {
if parser.UseWasm() {

10
internal/binding/converter/input.go
View file

@ -482,7 +482,7 @@ func GoInputJS(name, value string, f *parser.Function, p string) string {
return fmt.Sprintf("func() js.Value {\ntmp := js.TypedArrayOf([]byte(strings.Join(%v, \"|\")))\nreturn js.ValueOf(map[string]interface{}{\"data\": tmp, \"data_ptr\": unsafe.Pointer(&tmp)})\n}()", name)
}
if f.SignalMode != parser.CALLBACK {
return fmt.Sprintf("func() *js.Object {\ntmp := new(js.Object)\nif js.InternalObject(%v).Get(\"$val\") == js.Undefined {\ntmp.Set(\"data\", []byte(js.InternalObject(%v).Call(\"join\", \"|\").String()))\n} else {\ntmp.Set(\"data\", []byte(strings.Join(%v, \"|\")))\n}\nreturn tmp\n}()", name, name, name)
return fmt.Sprintf("func() *js.Object {\ntmp := new(js.Object)\nif js.InternalObject(%v).Get(\"$val\") == js.Undefined {\ntmp.Set(\"data\", []byte(js.InternalObject(%v).Call(\"join\", \"|\").String()))\n} else {\ntmp.Set(\"data\", []byte(strings.Join(%v, \"|\")))\n}\nreturn tmp\n}()", name, name, name) //needed for indirect exported pure js call -> can be ommited if build without js support
}
return fmt.Sprintf("func() *js.Object {\ntmp := new(js.Object)\ntmp.Set(\"data\", []byte(strings.Join(%v, \"|\")))\nreturn tmp\n}()", name)
}
@ -503,7 +503,7 @@ func GoInputJS(name, value string, f *parser.Function, p string) string {
return fmt.Sprintf("func() js.Value {\ntmp := js.TypedArrayOf([]byte(strings.Join(%v, \"|\")))\nreturn js.ValueOf(map[string]interface{}{\"data\": tmp, \"data_ptr\": unsafe.Pointer(&tmp)})\n}()", name)
}
if f.SignalMode != parser.CALLBACK {
return fmt.Sprintf("func() *js.Object {\ntmp := new(js.Object)\nif js.InternalObject(%v).Get(\"$val\") == js.Undefined {\ntmp.Set(\"data\", []byte(js.InternalObject(%v).Call(\"join\", \"|\").String()))\n} else {\ntmp.Set(\"data\", []byte(strings.Join(%v, \"|\")))\n}\nreturn tmp\n}()", name, name, name)
return fmt.Sprintf("func() *js.Object {\ntmp := new(js.Object)\nif js.InternalObject(%v).Get(\"$val\") == js.Undefined {\ntmp.Set(\"data\", []byte(js.InternalObject(%v).Call(\"join\", \"|\").String()))\n} else {\ntmp.Set(\"data\", []byte(strings.Join(%v, \"|\")))\n}\nreturn tmp\n}()", name, name, name) //needed for indirect exported pure js call -> can be ommited if build without js support
}
return fmt.Sprintf("func() *js.Object {\ntmp := new(js.Object)\ntmp.Set(\"data\", []byte(strings.Join(%v, \"|\")))\nreturn tmp\n}()", name)
}
@ -609,14 +609,14 @@ func GoInputJS(name, value string, f *parser.Function, p string) string {
if parser.UseWasm() || f.SignalMode == parser.CALLBACK {
return fmt.Sprintf("int64(%v)", name)
} else {
return fmt.Sprintf("func() int64 {\nif js.InternalObject(%v).Get(\"$val\") == js.Undefined {\nreturn int64(js.InternalObject(%v).Int64())\n}\nreturn int64(%v)\n}()", name, name, name) //needed for pure js call
return fmt.Sprintf("func() int64 {\nif js.InternalObject(%v).Get(\"$val\") == js.Undefined {\nreturn int64(js.InternalObject(%v).Int64())\n}\nreturn int64(%v)\n}()", name, name, name) //needed for indirect exported pure js call -> can be ommited if build without js support
}
}
if parser.UseWasm() {
return fmt.Sprintf("int64(%v.%v(%v))", module(c.Module), goEnum(f, value), name)
}
if f.SignalMode != parser.CALLBACK {
return fmt.Sprintf("func() %[1]v.%[2]v {\nif js.InternalObject(%[3]v).Get(\"$val\") == js.Undefined {\nreturn %[1]v.%[2]v(js.InternalObject(%[3]v).Int64())\n}\nreturn %[1]v.%[2]v(%[3]v)\n}()", module(c.Module), goEnum(f, value), name) //needed for pure js call
return fmt.Sprintf("func() %[1]v.%[2]v {\nif js.InternalObject(%[3]v).Get(\"$val\") == js.Undefined {\nreturn %[1]v.%[2]v(js.InternalObject(%[3]v).Int64())\n}\nreturn %[1]v.%[2]v(%[3]v)\n}()", module(c.Module), goEnum(f, value), name) //needed for indirect exported pure js call -> can be ommited if build without js support
}
return fmt.Sprintf("%v.%v(%v)", module(c.Module), goEnum(f, value), name)
}
@ -624,7 +624,7 @@ func GoInputJS(name, value string, f *parser.Function, p string) string {
return fmt.Sprintf("int64(%v(%v))", goEnum(f, value), name)
}
if f.SignalMode != parser.CALLBACK {
return fmt.Sprintf("func() %[1]v {\nif js.InternalObject(%[2]v).Get(\"$val\") == js.Undefined {\nreturn %[1]v(js.InternalObject(%[2]v).Int64())\n}\nreturn %[1]v(%[2]v)\n}()", goEnum(f, value), name) //needed for pure js call
return fmt.Sprintf("func() %[1]v {\nif js.InternalObject(%[2]v).Get(\"$val\") == js.Undefined {\nreturn %[1]v(js.InternalObject(%[2]v).Int64())\n}\nreturn %[1]v(%[2]v)\n}()", goEnum(f, value), name) //needed for indirect exported pure js call -> can be ommited if build without js support
}
return fmt.Sprintf("%v(%v)", goEnum(f, value), name)
}

8
internal/binding/converter/output.go
View file

@ -410,6 +410,10 @@ func cgoOutput(name, value string, f *parser.Function, p string) string {
case isClass(value):
{
if parser.UseJs() && f.SignalMode != parser.CALLBACK {
name = fmt.Sprintf("func() uintptr { if %v != js.Undefined { return uintptr(%v.Call(\"Pointer\").Int64()) }; return 0 }()", name, name)
}
if strings.Contains(value, ".") {
value = strings.Split(value, ".")[1]
}
@ -553,8 +557,8 @@ func cppOutputPacked(name, value string, f *parser.Function) string {
}
//TODO: remove hex encoding once QByteArray <-> ArrayBuffer conversion is possible and/or more TypedArray functions are available for gopherjs/wasm
//TODO: make exemption for QString and QStringList? they usually won't need the extra hex encoding ...
//TOOD: or use malloc and simply return a pointer ?
//TODO: make exemption for QString and QStringList for now? they usually won't need the extra hex encoding ...
//TOOD: or use malloc and simply return a pointer? instead waiting for gopherjs/wasm?
func cppOutputPackingStringForJs(name, length string) string {
if parser.UseJs() {
return fmt.Sprintf("emscripten::val ret = emscripten::val::object(); ret.set(\"data\", QByteArray::fromRawData(%v, %v).toHex().toStdString()); ret.set(\"len\", %v); ret;", name, length, length)

2
internal/binding/parser/function.go
View file

@ -357,7 +357,7 @@ func (f *Function) IsSupported() bool {
f.Fullname == "QAndroidBinder::onTransact", f.Fullname == "QtAndroid::checkPermission",
UseJs() &&
(strings.Contains(f.Name, "ibraryPath") || f.Fullname == "QLockFile::getLockInfo" || f.Name == "metric" || f.Name == "moveCursor" ||
(strings.Contains(f.Name, "ibraryPath") || f.Fullname == "QLockFile::getLockInfo" ||
f.Name == "inputMethodEvent" || f.Name == "updateInputMethod" || f.Name == "inputMethodQuery" ||
f.Fullname == "QHeaderView::isFirstSectionMovable" || f.Fullname == "QXmlSimpleReader::property" || f.Fullname == "QXmlReader::property" ||
f.Fullname == "QWebSocket::ignoreSslErrors" || f.Fullname == "QWebSocket::preSharedKeyAuthenticationRequired" ||

12
internal/binding/parser/helper.go
View file

@ -136,7 +136,13 @@ func CleanName(name, value string) string {
"ptr",
"register",
"forever",
"len":
"len",
"unsafe",
"log",
"runtime",
"errors",
"time",
"hex":
{
return name[:len(name)-2]
}
@ -151,9 +157,9 @@ func CleanName(name, value string) string {
}
}
case "f", "fmt":
case "f", "fmt", "qt", "js":
{
return "fo"
return name + name
}
}

6
internal/binding/templater/function_go.go
View file

@ -346,12 +346,8 @@ func goFunctionBody(function *parser.Function) string {
}
if converter.GoHeaderOutput(&headerOutputFakeFunc) == "" {
if parser.UseWasm() {
//TODO: workaround for https://github.com/golang/go/issues/26045#issuecomment-400017599
fmt.Fprintf(bb, "go signal.(%v)(%v)", converter.GoHeaderInputSignalFunction(function), converter.GoInputParametersForCallback(function))
} else {
//TODO wasm: wait for fix to https://github.com/golang/go/issues/26045#issuecomment-400017599
fmt.Fprintf(bb, "signal.(%v)(%v)", converter.GoHeaderInputSignalFunction(function), converter.GoInputParametersForCallback(function))
}
} else {
if function.Name == "readData" && len(function.Parameters) == 2 {
if !UseJs() {

1
internal/binding/templater/template_cgo_qmake.go
View file

@ -529,7 +529,6 @@ func createCgo(module, path, target string, mode int, ipkg, tags string) string
if utils.QT_DEBUG() {
tmp = strings.Replace(tmp, "-s USE_FREETYPE=1", "-s USE_FREETYPE=1 -s ASSERTIONS=1", -1)
}
tmp = strings.Replace(tmp, "-s NO_EXIT_RUNTIME=0", "-s NO_EXIT_RUNTIME=1", -1) //TODO: block main instead
}
for _, variable := range []string{"DEFINES", "SUBLIBS", "EXPORT_QMAKE_XARCH_CFLAGS", "EXPORT_QMAKE_XARCH_LFLAGS", "EXPORT_ARCH_ARGS", "-fvisibility=hidden", "-fembed-bitcode"} {

9
internal/binding/templater/template_go.go
View file

@ -500,7 +500,10 @@ func (ptr *%[1]v) Destroy%[1]v() {
for _, c := range parser.SortedClassesForModule(module, true) {
for _, f := range c.Functions {
if f.Meta != parser.CONSTRUCTOR {
if f.Meta != parser.CONSTRUCTOR && !f.Static {
continue
}
if strings.Contains(f.Name, "RegisterMetaType") || strings.Contains(f.Name, "RegisterType") { //TODO:
continue
}
if !f.IsSupported() {
@ -518,7 +521,11 @@ func (ptr *%[1]v) Destroy%[1]v() {
if parser.UseWasm() {
out = "" //TODO: export classes for jsinterop example
} else {
if converter.GoHeaderOutput(f) != "" {
out = fmt.Sprintf("module.Set(\"%v\", func(%v) *js.Object { return qt.MakeWrapper(%v(%v)); })\n", converter.GoHeaderName(f), ip, converter.GoHeaderName(f), converter.GoInputParametersForCallback(f))
} else {
out = fmt.Sprintf("module.Set(\"%v\", func(%v) { %v(%v); })\n", converter.GoHeaderName(f), ip, converter.GoHeaderName(f), converter.GoInputParametersForCallback(f))
}
}
if !strings.Contains(out, "unsupported_") && !strings.Contains(out, "C.") && strings.Contains(bb.String(), converter.GoHeaderName(f)+"(") {
bb.WriteString(out)

2
internal/ci/darwin.sh
View file

@ -20,7 +20,7 @@ else
QT=qt-unified-mac-x64-online
curl -sL --retry 10 --retry-delay 10 -o /tmp/$QT.dmg https://download.qt.io/official_releases/online_installers/$QT.dmg
hdiutil attach -noverify -noautofsck -quiet /tmp/$QT.dmg
QT=qt-unified-mac-x64-3.0.2-online
QT=qt-unified-mac-x64-3.0.5-online
if [ "$IOS" == "true" ] || [ "$IOS_SIMULATOR" == "true" ]
then
/Volumes/$QT/$QT.app/Contents/MacOS/$QT -v --script $GOPATH/src/github.com/therecipe/qt/internal/ci/iscript.qs IOS=true

46
internal/cmd/deploy/assets.go
View file

@ -193,7 +193,7 @@ func ios_plist(name string) string {
<key>CFBundleGetInfoString</key>
<string>Created by Qt/QMake</string>
<key>CFBundleIdentifier</key>
<string>com.yourcompany.%[1]v</string>
<string>%[2]v</string>
<key>CFBundleName</key>
<string>%[1]v</string>
<key>CFBundlePackageType</key>
@ -223,7 +223,7 @@ func ios_plist(name string) string {
<true/>
</dict>
</plist>
`, name)
`, name, strings.Replace(name, "_", "", -1))
}
func ios_launchscreen(name string) string {
@ -334,7 +334,7 @@ func ios_appicon() string {
`
}
func ios_xcodeproject(depPath string) string {
func ios_xcodeproject() string {
return `// !$*UTF8*$!
{
archiveVersion = 1;
@ -727,9 +727,9 @@ go tool link -f -o $PWD/relinked -importcfg $PWD/b001/importcfg.link -buildmode=
//js/wasm
func js_c_main_wrapper() string {
func js_c_main_wrapper(target string) string {
bb := new(bytes.Buffer)
bb.WriteString("#include <emscripten/val.h>\n")
bb.WriteString("#include <emscripten.h>\n")
for _, n := range rcc.ResourceNames {
fmt.Fprintf(bb, "extern int qInitResources_%v();\n", n)
}
@ -738,18 +738,16 @@ func js_c_main_wrapper() string {
fmt.Fprintf(bb, "qInitResources_%v();\n", n)
}
//TODO: use eval in EM_ASM instead ? also make blocking with emscripten_sync_run_in_main_runtime_thread or something
bb.WriteString("emscripten::val document = emscripten::val::global(\"document\");\n")
bb.WriteString("emscripten::val script = document.call<emscripten::val>(\"createElement\", emscripten::val(\"script\"));\n")
bb.WriteString("script.set(\"src\", emscripten::val(\"go.js\"));\n")
bb.WriteString("document[\"body\"].call<void>(\"appendChild\", script);\n")
//TODO: use emscripten_sync_run_in_main_runtime_thread once thread support is there ?
bb.WriteString("emscripten_run_script(\"Module._goMain()\");")
bb.WriteString("}")
return bb.String()
}
//TODO: cleanup
func wasm_js() string {
return `
if (!WebAssembly.instantiateStreaming) { // polyfill
WebAssembly.instantiateStreaming = async (resp, importObject) => {
const source = await (await resp).arrayBuffer();
@ -757,21 +755,27 @@ if (!WebAssembly.instantiateStreaming) { // polyfill
};
}
const go = new Go();
WebAssembly.instantiateStreaming(fetch("go.wasm"), go.importObject).then((result) => {
go.run(result.instance);
let go = new Go();
let instance;
let fetchPromise = fetch("go.wasm");
WebAssembly.instantiateStreaming(fetchPromise, go.importObject).then((result) => {
instance = result.instance;
}).catch((err) => {
//console.error(err);
//console.log(err);
fetch('go.wasm').then(response =>
//fallback for wrong MIME type
fetchPromise.then((response) =>
response.arrayBuffer()
).then(bytes =>
).then((bytes) =>
WebAssembly.instantiate(bytes, go.importObject)
).then(result => {
go.run(result.instance);
});
).then((result) =>
instance = result.instance
);
});
Module._goMain = function() {
go.run(instance);
};
})();`
}

7
internal/cmd/deploy/build.go
View file

@ -22,9 +22,6 @@ func build(mode, target, path, ldFlagsCustom, tagsCustom, name, depPath string,
if ((!fast || utils.QT_STUB()) && !utils.QT_FAT()) || target == "js" || target == "wasm" {
tags = append(tags, "minimal")
}
if ldFlagsCustom != "" {
ldFlags = append(ldFlags, strings.Split(ldFlagsCustom, " ")...)
}
if tagsCustom != "" {
tags = append(tags, strings.Split(tagsCustom, " ")...)
}
@ -57,12 +54,12 @@ func build(mode, target, path, ldFlagsCustom, tagsCustom, name, depPath string,
var extraLdFlag string
if utils.Log.Level == logrus.DebugLevel && target != "wasm" {
extraLdFlag = " \"-extldflags=-v\""
ldFlags = append(ldFlags, "-extldflags=-v")
}
cmd := exec.Command("go", "build", "-p", strconv.Itoa(runtime.GOMAXPROCS(0)), "-v")
if len(ldFlags) > 0 || len(extraLdFlag) > 0 {
cmd.Args = append(cmd.Args, fmt.Sprintf("-ldflags=%v\"%v\"%v", pattern, strings.Join(ldFlags, "\" \""), extraLdFlag))
cmd.Args = append(cmd.Args, fmt.Sprintf("-ldflags=%v%v", pattern, escapeFlags(ldFlags, ldFlagsCustom)))
}
cmd.Args = append(cmd.Args, "-o", out+ending)

38
internal/cmd/deploy/build_escape.go Normal file
View file

@ -0,0 +1,38 @@
package deploy
import (
"fmt"
"strings"
)
func escapeFlags(ldFlags []string, ldFlagsCustom string) string {
for _, s := range []string{"\"", "'"} {
var newldFlagsCustom []string
var insideQuotes bool
for i, f := range strings.Split(ldFlagsCustom, s) {
if i > 0 {
if !insideQuotes {
if strings.Contains(f, " ") {
insideQuotes = true
f = strings.Replace(f, " ", "_DONT_ESCAPE_", -1)
}
} else {
insideQuotes = false
}
}
newldFlagsCustom = append(newldFlagsCustom, f)
}
if len(newldFlagsCustom) > 0 {
ldFlagsCustom = strings.Join(newldFlagsCustom, "")
}
}
if len(ldFlagsCustom) > 0 {
ldFlags = append(ldFlags, strings.Split(ldFlagsCustom, " ")...)
}
if out := strings.Replace(strings.Join(ldFlags, "\" \""), "_DONT_ESCAPE_", " ", -1); len(out) > 0 {
return fmt.Sprintf("\"%v\"", out)
}
return ""
}

74
internal/cmd/deploy/build_test.go Normal file
View file

@ -0,0 +1,74 @@
package deploy
import (
"fmt"
"io/ioutil"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"testing"
)
func Test_escapeFlags(t *testing.T) {
tmpfile := filepath.Join(os.TempDir(), "escapeFlags.go")
defer os.Remove(tmpfile)
if err := ioutil.WriteFile(tmpfile, []byte("package main;var foo, abc string;func main() { println(foo, abc) }"), 0644); err != nil {
t.Fatal(err)
}
var pattern string
if strings.Contains(runtime.Version(), "1.1") || strings.Contains(runtime.Version(), "devel") {
pattern = "all="
}
for _, flags := range [][]string{
{},
{"-w"},
{"-w", "-s"},
{"-w", "-s", "-extldflags=-v"},
{"-w", "-s", "-extldflags=-v"},
} {
for i, tc := range []string{
"",
"-X main.foo=bar",
"-X \"main.foo=bar\"",
"-X 'main.foo=bar'",
} {
cmd := exec.Command("go", "run", "-v", fmt.Sprintf("-ldflags=%v%v", pattern, escapeFlags(flags, tc)), tmpfile)
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatal(err, string(out), cmd.Args)
}
outC := "bar"
if tc == "" {
outC = ""
}
if outT := strings.TrimSpace(string(out)); outT != outC {
t.Fatal(i, outT, "!=", outC)
}
}
for i, tc := range []string{
"",
"-X \"main.foo=bar baz\" -X \"main.abc=bbb ddd\"",
"-X \"main.foo=bar baz\" -X 'main.abc=bbb ddd'",
"-X 'main.foo=bar baz' -X 'main.abc=bbb ddd'",
} {
cmd := exec.Command("go", "run", "-v", fmt.Sprintf("-ldflags=%v%v", pattern, escapeFlags(flags, tc)), tmpfile)
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatal(err, string(out), cmd.Args)
}
outC := "bar baz bbb ddd"
if tc == "" {
outC = ""
}
if outT := strings.TrimSpace(string(out)); outT != outC {
t.Fatal(i, outT, "!=", outC)
}
}
}
}

39
internal/cmd/deploy/bundle.go
View file

@ -18,7 +18,7 @@ import (
"github.com/therecipe/qt/internal/utils"
)
func bundle(mode, target, path, name, depPath string, tagsCustom string) {
func bundle(mode, target, path, name, depPath string, tagsCustom string, fast bool) {
copy := func(src, dst string) {
copy := "cp"
@ -488,7 +488,7 @@ func bundle(mode, target, path, name, depPath string, tagsCustom string) {
utils.Save(filepath.Join(buildPath, "Info.plist"), ios_plist(name))
utils.Save(filepath.Join(buildPath, "Images.xcassets", "AppIcon.appiconset", "Contents.json"), ios_appicon())
utils.Save(filepath.Join(buildPath, "LaunchScreen.xib"), ios_launchscreen(name))
utils.Save(filepath.Join(buildPath, "project.xcodeproj", "project.pbxproj"), ios_xcodeproject(depPath))
utils.Save(filepath.Join(buildPath, "project.xcodeproj", "project.pbxproj"), ios_xcodeproject())
copy(filepath.Join(utils.QT_DIR(), utils.QT_VERSION_MAJOR(), "ios", "mkspecs", "macx-ios-clang", "Default-568h@2x.png"), buildPath)
//copy custom assets
@ -496,11 +496,6 @@ func bundle(mode, target, path, name, depPath string, tagsCustom string) {
utils.MkdirAll(assets)
copy(assets+"/.", buildPath)
//add c_main_wrappers
if !utils.ExistsFile(filepath.Join(depPath, target+"_qml_plugin_import.cpp")) {
utils.Save(filepath.Join(depPath, target+"_qml_plugin_import.cpp"), "")
}
var t string
switch target {
case "ios":
@ -511,7 +506,12 @@ func bundle(mode, target, path, name, depPath string, tagsCustom string) {
utils.Save(filepath.Join(depPath, "c_main_wrapper_"+t+".cpp"), ios_c_main_wrapper())
rcc.ResourceNames = make(map[string]string)
cmd := exec.Command("xcrun", "clang++", "c_main_wrapper_"+t+".cpp", target+"_plugin_import.cpp", target+"_qml_plugin_import.cpp", "-o", "build/main", "-u", "_qt_registerPlatformPlugin", "-Wl,-e,_qt_main_wrapper", "-I../..", "-L.", "-lgo")
cmd := exec.Command("xcrun", "clang++", "c_main_wrapper_"+t+".cpp", target+"_plugin_import.cpp")
if utils.ExistsFile(filepath.Join(depPath, target+"_qml_plugin_import.cpp")) {
cmd.Args = append(cmd.Args, target+"_qml_plugin_import.cpp")
}
cmd.Args = append(cmd.Args, "-o", "build/main", "-u", "_qt_registerPlatformPlugin", "-Wl,-e,_qt_main_wrapper", "-I../..", "-L.", "-lgo")
cmd.Dir = depPath
cmd.Args = append(cmd.Args, templater.GetiOSClang(target, t, depPath)...)
utils.RunCmd(cmd, fmt.Sprintf("compile wrapper for %v (%v) on %v", target, t, runtime.GOOS))
@ -608,9 +608,16 @@ func bundle(mode, target, path, name, depPath string, tagsCustom string) {
}
//patch default assets
utils.Save(filepath.Join(depPath, "index.html"), strings.Replace(utils.Load(filepath.Join(depPath, "index.html")), "APPNAME", "main", -1))
index := utils.Load(filepath.Join(depPath, "index.html"))
index = strings.Replace(index, "APPNAME", "main", -1)
utils.Save(filepath.Join(depPath, "index.html"), strings.Replace(index, " </body>", " <script type=\"text/javascript\" src=\"go.js\"></script>\n </body>", -1))
if parser.UseWasm() {
utils.Save(filepath.Join(depPath, "go.js"), strings.Replace(utils.Load(filepath.Join(depPath, "go.js")), "})();", wasm_js(), -1))
} else {
gojs := utils.Load(filepath.Join(depPath, "go.js"))
gojs = strings.Replace(gojs, "(function() {", "Module._goMain = function() {", -1)
utils.Save(filepath.Join(depPath, "go.js"), strings.Replace(gojs, "}).call(this);", "};", -1))
}
//copy custom assets
@ -618,14 +625,16 @@ func bundle(mode, target, path, name, depPath string, tagsCustom string) {
utils.MkdirAll(assets)
copy(assets+"/.", depPath)
//add c_main_wrappers
if !utils.ExistsFile(filepath.Join(depPath, target+".js_qml_plugin_import.cpp")) {
utils.Save(filepath.Join(depPath, target+".js_qml_plugin_import.cpp"), "")
if fast {
break
}
utils.Save(filepath.Join(depPath, "c_main_wrapper_js.cpp"), js_c_main_wrapper())
utils.Save(filepath.Join(depPath, "c_main_wrapper_js.cpp"), js_c_main_wrapper(target))
env, _, _, _ := cmd.BuildEnv(target, "", "")
cmd := exec.Command(filepath.Join(env["EMSCRIPTEN"], "em++"), "c_main_wrapper_js.cpp", target+".js_plugin_import.cpp", target+".js_qml_plugin_import.cpp")
cmd := exec.Command(filepath.Join(env["EMSCRIPTEN"], "em++"), "c_main_wrapper_js.cpp", target+".js_plugin_import.cpp")
if utils.ExistsFile(filepath.Join(depPath, target+".js_qml_plugin_import.cpp")) {
cmd.Args = append(cmd.Args, target+".js_qml_plugin_import.cpp")
}
cmd.Dir = depPath
for rccFile := range rcc.ResourceNames {
@ -681,7 +690,6 @@ func bundle(mode, target, path, name, depPath string, tagsCustom string) {
//<-
//TODO: check if minimal packages are stale and skip main.js rebuild this if they aren't
//TODO: pack js into wasm
cmd.Args = append(cmd.Args, []string{"-o", "main.js"}...)
cmd.Args = append(cmd.Args, templater.GetiOSClang(target, "", depPath)...)
@ -693,7 +701,6 @@ func bundle(mode, target, path, name, depPath string, tagsCustom string) {
utils.RemoveAll(filepath.Join(depPath, "c_main_wrapper_js.cpp"))
utils.RemoveAll(filepath.Join(depPath, target+".js_plugin_import.cpp"))
utils.RemoveAll(filepath.Join(depPath, target+".js_qml_plugin_import.cpp"))
//TODO: remove packed go.js
utils.RemoveAll(filepath.Join(depPath, "go.js.map"))
}

4
internal/cmd/deploy/deploy.go
View file

@ -64,8 +64,8 @@ func Deploy(mode, target, path string, docker bool, ldFlags, tags string, fast b
build(mode, target, path, ldFlags, tags, name, depPath, fast, comply)
if !(fast || (utils.QT_DEBUG_QML() && target == runtime.GOOS)) {
bundle(mode, target, path, name, depPath, tags)
if !(fast || (utils.QT_DEBUG_QML() && target == runtime.GOOS)) || (target == "js" || target == "wasm") {
bundle(mode, target, path, name, depPath, tags, fast)
}
}

14
internal/docker/docker_pipelines_template.yml
View file

@ -11,20 +11,20 @@ jobs:
file: js/Dockerfile
tag: js
dep:
- js_base
# - js_base
- linux
-
template: docker_job_template.yml
parameters:
file: js/Dockerfile.base
tag: js_base
# -
# template: docker_job_template.yml
# parameters:
# file: js/Dockerfile.base
# tag: js_base
-
template: docker_job_template.yml
parameters:
file: js/Dockerfile.wasm
tag: wasm
dep:
- js_base
# - js_base
- linux
-
template: docker_job_template.yml

1
internal/examples/widgets/textedit/textedit.go
View file

@ -425,6 +425,7 @@ func (t *TextEdit) load(f string) bool {
if !file.Open(core.QIODevice__ReadOnly) {
return false
}
defer file.Close()
var (
data = file.ReadAll()

12
internal/utils/utils.go
View file

@ -12,23 +12,11 @@ import (
func ExistsFile(name string) bool {
_, err := ioutil.ReadFile(name)
if err != nil {
_, errS := ioutil.ReadDir(name)
if errS == nil {
logrus.WithError(err).WithField("path", name).Warn("should be file, not dir")
}
}
return err == nil
}
func ExistsDir(name string) bool {
_, err := ioutil.ReadDir(name)
if err != nil {
_, errS := ioutil.ReadFile(name)
if errS == nil {
logrus.WithError(err).WithField("path", name).Warn("should be dir, not file")
}
}
return err == nil
}

28
multimedia/multimedia.cpp
View file

@ -512,7 +512,7 @@ public:
void reset() { callbackQAbstractAudioInput_Reset(this); };
void resume() { callbackQAbstractAudioInput_Resume(this); };
void setBufferSize(int value) { callbackQAbstractAudioInput_SetBufferSize(this, value); };
void setFormat(const QAudioFormat & fo) { callbackQAbstractAudioInput_SetFormat(this, const_cast<QAudioFormat*>(&fo)); };
void setFormat(const QAudioFormat & fmtfmt) { callbackQAbstractAudioInput_SetFormat(this, const_cast<QAudioFormat*>(&fmtfmt)); };
void setNotifyInterval(int ms) { callbackQAbstractAudioInput_SetNotifyInterval(this, ms); };
void setVolume(qreal vqr) { callbackQAbstractAudioInput_SetVolume(this, vqr); };
void start(QIODevice * device) { callbackQAbstractAudioInput_Start(this, device); };
@ -607,9 +607,9 @@ void QAbstractAudioInput_SetBufferSize(void* ptr, int value)
static_cast<QAbstractAudioInput*>(ptr)->setBufferSize(value);
}
void QAbstractAudioInput_SetFormat(void* ptr, void* fo)
void QAbstractAudioInput_SetFormat(void* ptr, void* fmtfmt)
{
static_cast<QAbstractAudioInput*>(ptr)->setFormat(*static_cast<QAudioFormat*>(fo));
static_cast<QAbstractAudioInput*>(ptr)->setFormat(*static_cast<QAudioFormat*>(fmtfmt));
}
void QAbstractAudioInput_SetNotifyInterval(void* ptr, int ms)
@ -898,7 +898,7 @@ public:
void resume() { callbackQAbstractAudioOutput_Resume(this); };
void setBufferSize(int value) { callbackQAbstractAudioOutput_SetBufferSize(this, value); };
void setCategory(const QString & vqs) { QByteArray tda39a3 = vqs.toUtf8(); QtMultimedia_PackedString vqsPacked = { const_cast<char*>(tda39a3.prepend("WHITESPACE").constData()+10), tda39a3.size()-10 };callbackQAbstractAudioOutput_SetCategory(this, vqsPacked); };
void setFormat(const QAudioFormat & fo) { callbackQAbstractAudioOutput_SetFormat(this, const_cast<QAudioFormat*>(&fo)); };
void setFormat(const QAudioFormat & fmtfmt) { callbackQAbstractAudioOutput_SetFormat(this, const_cast<QAudioFormat*>(&fmtfmt)); };
void setNotifyInterval(int ms) { callbackQAbstractAudioOutput_SetNotifyInterval(this, ms); };
void setVolume(qreal volume) { callbackQAbstractAudioOutput_SetVolume(this, volume); };
void start(QIODevice * device) { callbackQAbstractAudioOutput_Start(this, device); };
@ -1004,9 +1004,9 @@ void QAbstractAudioOutput_SetCategoryDefault(void* ptr, struct QtMultimedia_Pack
static_cast<QAbstractAudioOutput*>(ptr)->QAbstractAudioOutput::setCategory(QString::fromUtf8(vqs.data, vqs.len));
}
void QAbstractAudioOutput_SetFormat(void* ptr, void* fo)
void QAbstractAudioOutput_SetFormat(void* ptr, void* fmtfmt)
{
static_cast<QAbstractAudioOutput*>(ptr)->setFormat(*static_cast<QAudioFormat*>(fo));
static_cast<QAbstractAudioOutput*>(ptr)->setFormat(*static_cast<QAudioFormat*>(fmtfmt));
}
void QAbstractAudioOutput_SetNotifyInterval(void* ptr, int ms)
@ -17077,9 +17077,9 @@ void* QMediaTimeInterval_Translated(void* ptr, long long offset)
return new QMediaTimeInterval(static_cast<QMediaTimeInterval*>(ptr)->translated(offset));
}
char QMediaTimeInterval_Contains(void* ptr, long long time)
char QMediaTimeInterval_Contains(void* ptr, long long ti)
{
return static_cast<QMediaTimeInterval*>(ptr)->contains(time);
return static_cast<QMediaTimeInterval*>(ptr)->contains(ti);
}
char QMediaTimeInterval_IsNormal(void* ptr)
@ -17162,9 +17162,9 @@ struct QtMultimedia_PackedList QMediaTimeRange_Intervals(void* ptr)
return ({ QList<QMediaTimeInterval>* tmpValue = new QList<QMediaTimeInterval>(static_cast<QMediaTimeRange*>(ptr)->intervals()); QtMultimedia_PackedList { tmpValue, tmpValue->size() }; });
}
char QMediaTimeRange_Contains(void* ptr, long long time)
char QMediaTimeRange_Contains(void* ptr, long long ti)
{
return static_cast<QMediaTimeRange*>(ptr)->contains(time);
return static_cast<QMediaTimeRange*>(ptr)->contains(ti);
}
char QMediaTimeRange_IsContinuous(void* ptr)
@ -20516,9 +20516,9 @@ struct QtMultimedia_PackedString QVideoFrame_Bits2(void* ptr, int plane)
return ({ char* t8420e9 = static_cast<char*>(static_cast<void*>(static_cast<QVideoFrame*>(ptr)->bits(plane))); QtMultimedia_PackedString { t8420e9, -1 }; });
}
void QVideoFrame_SetEndTime(void* ptr, long long time)
void QVideoFrame_SetEndTime(void* ptr, long long ti)
{
static_cast<QVideoFrame*>(ptr)->setEndTime(time);
static_cast<QVideoFrame*>(ptr)->setEndTime(ti);
}
void QVideoFrame_SetFieldType(void* ptr, long long field)
@ -20531,9 +20531,9 @@ void QVideoFrame_SetMetaData(void* ptr, struct QtMultimedia_PackedString key, vo
static_cast<QVideoFrame*>(ptr)->setMetaData(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(value));
}
void QVideoFrame_SetStartTime(void* ptr, long long time)
void QVideoFrame_SetStartTime(void* ptr, long long ti)
{
static_cast<QVideoFrame*>(ptr)->setStartTime(time);
static_cast<QVideoFrame*>(ptr)->setStartTime(ti);
}
void QVideoFrame_Unmap(void* ptr)

48
multimedia/multimedia.go
View file

@ -1216,20 +1216,20 @@ func (ptr *QAbstractAudioInput) SetBufferSize(value int) {
}
//export callbackQAbstractAudioInput_SetFormat
func callbackQAbstractAudioInput_SetFormat(ptr unsafe.Pointer, fo unsafe.Pointer) {
func callbackQAbstractAudioInput_SetFormat(ptr unsafe.Pointer, fmtfmt unsafe.Pointer) {
if signal := qt.GetSignal(ptr, "setFormat"); signal != nil {
signal.(func(*QAudioFormat))(NewQAudioFormatFromPointer(fo))
signal.(func(*QAudioFormat))(NewQAudioFormatFromPointer(fmtfmt))
}
}
func (ptr *QAbstractAudioInput) ConnectSetFormat(f func(fo *QAudioFormat)) {
func (ptr *QAbstractAudioInput) ConnectSetFormat(f func(fmtfmt *QAudioFormat)) {
if ptr.Pointer() != nil {
if signal := qt.LendSignal(ptr.Pointer(), "setFormat"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "setFormat", func(fo *QAudioFormat) {
signal.(func(*QAudioFormat))(fo)
f(fo)
qt.ConnectSignal(ptr.Pointer(), "setFormat", func(fmtfmt *QAudioFormat) {
signal.(func(*QAudioFormat))(fmtfmt)
f(fmtfmt)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "setFormat", f)
@ -1244,9 +1244,9 @@ func (ptr *QAbstractAudioInput) DisconnectSetFormat() {
}
}
func (ptr *QAbstractAudioInput) SetFormat(fo QAudioFormat_ITF) {
func (ptr *QAbstractAudioInput) SetFormat(fmtfmt QAudioFormat_ITF) {
if ptr.Pointer() != nil {
C.QAbstractAudioInput_SetFormat(ptr.Pointer(), PointerFromQAudioFormat(fo))
C.QAbstractAudioInput_SetFormat(ptr.Pointer(), PointerFromQAudioFormat(fmtfmt))
}
}
@ -2467,20 +2467,20 @@ func (ptr *QAbstractAudioOutput) SetCategoryDefault(vqs string) {
}
//export callbackQAbstractAudioOutput_SetFormat
func callbackQAbstractAudioOutput_SetFormat(ptr unsafe.Pointer, fo unsafe.Pointer) {
func callbackQAbstractAudioOutput_SetFormat(ptr unsafe.Pointer, fmtfmt unsafe.Pointer) {
if signal := qt.GetSignal(ptr, "setFormat"); signal != nil {
signal.(func(*QAudioFormat))(NewQAudioFormatFromPointer(fo))
signal.(func(*QAudioFormat))(NewQAudioFormatFromPointer(fmtfmt))
}
}
func (ptr *QAbstractAudioOutput) ConnectSetFormat(f func(fo *QAudioFormat)) {
func (ptr *QAbstractAudioOutput) ConnectSetFormat(f func(fmtfmt *QAudioFormat)) {
if ptr.Pointer() != nil {
if signal := qt.LendSignal(ptr.Pointer(), "setFormat"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "setFormat", func(fo *QAudioFormat) {
signal.(func(*QAudioFormat))(fo)
f(fo)
qt.ConnectSignal(ptr.Pointer(), "setFormat", func(fmtfmt *QAudioFormat) {
signal.(func(*QAudioFormat))(fmtfmt)
f(fmtfmt)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "setFormat", f)
@ -2495,9 +2495,9 @@ func (ptr *QAbstractAudioOutput) DisconnectSetFormat() {
}
}
func (ptr *QAbstractAudioOutput) SetFormat(fo QAudioFormat_ITF) {
func (ptr *QAbstractAudioOutput) SetFormat(fmtfmt QAudioFormat_ITF) {
if ptr.Pointer() != nil {
C.QAbstractAudioOutput_SetFormat(ptr.Pointer(), PointerFromQAudioFormat(fo))
C.QAbstractAudioOutput_SetFormat(ptr.Pointer(), PointerFromQAudioFormat(fmtfmt))
}
}
@ -35085,9 +35085,9 @@ func (ptr *QMediaTimeInterval) Translated(offset int64) *QMediaTimeInterval {
return nil
}
func (ptr *QMediaTimeInterval) Contains(time int64) bool {
func (ptr *QMediaTimeInterval) Contains(ti int64) bool {
if ptr.Pointer() != nil {
return int8(C.QMediaTimeInterval_Contains(ptr.Pointer(), C.longlong(time))) != 0
return int8(C.QMediaTimeInterval_Contains(ptr.Pointer(), C.longlong(ti))) != 0
}
return false
}
@ -35238,9 +35238,9 @@ func (ptr *QMediaTimeRange) Intervals() []*QMediaTimeInterval {
return make([]*QMediaTimeInterval, 0)
}
func (ptr *QMediaTimeRange) Contains(time int64) bool {
func (ptr *QMediaTimeRange) Contains(ti int64) bool {
if ptr.Pointer() != nil {
return int8(C.QMediaTimeRange_Contains(ptr.Pointer(), C.longlong(time))) != 0
return int8(C.QMediaTimeRange_Contains(ptr.Pointer(), C.longlong(ti))) != 0
}
return false
}
@ -43603,9 +43603,9 @@ func (ptr *QVideoFrame) Bits2(plane int) string {
return ""
}
func (ptr *QVideoFrame) SetEndTime(time int64) {
func (ptr *QVideoFrame) SetEndTime(ti int64) {
if ptr.Pointer() != nil {
C.QVideoFrame_SetEndTime(ptr.Pointer(), C.longlong(time))
C.QVideoFrame_SetEndTime(ptr.Pointer(), C.longlong(ti))
}
}
@ -43626,9 +43626,9 @@ func (ptr *QVideoFrame) SetMetaData(key string, value core.QVariant_ITF) {
}
}
func (ptr *QVideoFrame) SetStartTime(time int64) {
func (ptr *QVideoFrame) SetStartTime(ti int64) {
if ptr.Pointer() != nil {
C.QVideoFrame_SetStartTime(ptr.Pointer(), C.longlong(time))
C.QVideoFrame_SetStartTime(ptr.Pointer(), C.longlong(ti))
}
}

12
multimedia/multimedia.h
View file

@ -143,7 +143,7 @@ void QAbstractAudioInput_Notify(void* ptr);
void QAbstractAudioInput_Reset(void* ptr);
void QAbstractAudioInput_Resume(void* ptr);
void QAbstractAudioInput_SetBufferSize(void* ptr, int value);
void QAbstractAudioInput_SetFormat(void* ptr, void* fo);
void QAbstractAudioInput_SetFormat(void* ptr, void* fmtfmt);
void QAbstractAudioInput_SetNotifyInterval(void* ptr, int ms);
void QAbstractAudioInput_SetVolume(void* ptr, double vqr);
void QAbstractAudioInput_Start(void* ptr, void* device);
@ -200,7 +200,7 @@ void QAbstractAudioOutput_Resume(void* ptr);
void QAbstractAudioOutput_SetBufferSize(void* ptr, int value);
void QAbstractAudioOutput_SetCategory(void* ptr, struct QtMultimedia_PackedString vqs);
void QAbstractAudioOutput_SetCategoryDefault(void* ptr, struct QtMultimedia_PackedString vqs);
void QAbstractAudioOutput_SetFormat(void* ptr, void* fo);
void QAbstractAudioOutput_SetFormat(void* ptr, void* fmtfmt);
void QAbstractAudioOutput_SetNotifyInterval(void* ptr, int ms);
void QAbstractAudioOutput_SetVolume(void* ptr, double volume);
void QAbstractAudioOutput_SetVolumeDefault(void* ptr, double volume);
@ -2222,7 +2222,7 @@ void* QMediaTimeInterval_NewQMediaTimeInterval3(void* other);
void* QMediaTimeInterval_NewQMediaTimeInterval2(long long start, long long end);
void* QMediaTimeInterval_Normalized(void* ptr);
void* QMediaTimeInterval_Translated(void* ptr, long long offset);
char QMediaTimeInterval_Contains(void* ptr, long long time);
char QMediaTimeInterval_Contains(void* ptr, long long ti);
char QMediaTimeInterval_IsNormal(void* ptr);
long long QMediaTimeInterval_End(void* ptr);
long long QMediaTimeInterval_Start(void* ptr);
@ -2239,7 +2239,7 @@ void QMediaTimeRange_RemoveInterval2(void* ptr, long long start, long long end);
void QMediaTimeRange_RemoveTimeRange(void* ptr, void* ran);
void QMediaTimeRange_DestroyQMediaTimeRange(void* ptr);
struct QtMultimedia_PackedList QMediaTimeRange_Intervals(void* ptr);
char QMediaTimeRange_Contains(void* ptr, long long time);
char QMediaTimeRange_Contains(void* ptr, long long ti);
char QMediaTimeRange_IsContinuous(void* ptr);
char QMediaTimeRange_IsEmpty(void* ptr);
long long QMediaTimeRange_EarliestTime(void* ptr);
@ -2724,10 +2724,10 @@ long long QVideoFrame_QVideoFrame_PixelFormatFromImageFormat(long long format);
char QVideoFrame_Map(void* ptr, long long mode);
struct QtMultimedia_PackedString QVideoFrame_Bits(void* ptr);
struct QtMultimedia_PackedString QVideoFrame_Bits2(void* ptr, int plane);
void QVideoFrame_SetEndTime(void* ptr, long long time);
void QVideoFrame_SetEndTime(void* ptr, long long ti);
void QVideoFrame_SetFieldType(void* ptr, long long field);
void QVideoFrame_SetMetaData(void* ptr, struct QtMultimedia_PackedString key, void* value);
void QVideoFrame_SetStartTime(void* ptr, long long time);
void QVideoFrame_SetStartTime(void* ptr, long long ti);
void QVideoFrame_Unmap(void* ptr);
void QVideoFrame_DestroyQVideoFrame(void* ptr);
long long QVideoFrame_HandleType(void* ptr);

36
network/network.cpp
View file

@ -3604,7 +3604,7 @@ public:
void Signal_NetworkAccessibleChanged(QNetworkAccessManager::NetworkAccessibility accessible) { callbackQNetworkAccessManager_NetworkAccessibleChanged(this, accessible); };
void Signal_PreSharedKeyAuthenticationRequired(QNetworkReply * reply, QSslPreSharedKeyAuthenticator * authenticator) { callbackQNetworkAccessManager_PreSharedKeyAuthenticationRequired(this, reply, authenticator); };
void Signal_ProxyAuthenticationRequired(const QNetworkProxy & proxy, QAuthenticator * authenticator) { callbackQNetworkAccessManager_ProxyAuthenticationRequired(this, const_cast<QNetworkProxy*>(&proxy), authenticator); };
void Signal_SslErrors(QNetworkReply * reply, const QList<QSslError> & errors) { callbackQNetworkAccessManager_SslErrors(this, reply, ({ QList<QSslError>* tmpValue = const_cast<QList<QSslError>*>(&errors); QtNetwork_PackedList { tmpValue, tmpValue->size() }; })); };
void Signal_SslErrors(QNetworkReply * reply, const QList<QSslError> & erro) { callbackQNetworkAccessManager_SslErrors(this, reply, ({ QList<QSslError>* tmpValue = const_cast<QList<QSslError>*>(&erro); QtNetwork_PackedList { tmpValue, tmpValue->size() }; })); };
~MyQNetworkAccessManager() { callbackQNetworkAccessManager_DestroyQNetworkAccessManager(this); };
QStringList supportedSchemesImplementation() const { return ({ QtNetwork_PackedString tempVal = callbackQNetworkAccessManager_SupportedSchemesImplementation(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("|", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQNetworkAccessManager_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
@ -3914,9 +3914,9 @@ void QNetworkAccessManager_DisconnectSslErrors(void* ptr)
QObject::disconnect(static_cast<QNetworkAccessManager*>(ptr), static_cast<void (QNetworkAccessManager::*)(QNetworkReply *, const QList<QSslError> &)>(&QNetworkAccessManager::sslErrors), static_cast<MyQNetworkAccessManager*>(ptr), static_cast<void (MyQNetworkAccessManager::*)(QNetworkReply *, const QList<QSslError> &)>(&MyQNetworkAccessManager::Signal_SslErrors));
}
void QNetworkAccessManager_SslErrors(void* ptr, void* reply, void* errors)
void QNetworkAccessManager_SslErrors(void* ptr, void* reply, void* erro)
{
static_cast<QNetworkAccessManager*>(ptr)->sslErrors(static_cast<QNetworkReply*>(reply), *static_cast<QList<QSslError>*>(errors));
static_cast<QNetworkAccessManager*>(ptr)->sslErrors(static_cast<QNetworkReply*>(reply), *static_cast<QList<QSslError>*>(erro));
}
void QNetworkAccessManager_DestroyQNetworkAccessManager(void* ptr)
@ -6066,14 +6066,14 @@ public:
void Signal_Error2(QNetworkReply::NetworkError code) { callbackQNetworkReply_Error2(this, code); };
void Signal_Finished() { callbackQNetworkReply_Finished(this); };
void ignoreSslErrors() { callbackQNetworkReply_IgnoreSslErrors(this); };
void ignoreSslErrorsImplementation(const QList<QSslError> & errors) { callbackQNetworkReply_IgnoreSslErrorsImplementation(this, ({ QList<QSslError>* tmpValue = const_cast<QList<QSslError>*>(&errors); QtNetwork_PackedList { tmpValue, tmpValue->size() }; })); };
void ignoreSslErrorsImplementation(const QList<QSslError> & erro) { callbackQNetworkReply_IgnoreSslErrorsImplementation(this, ({ QList<QSslError>* tmpValue = const_cast<QList<QSslError>*>(&erro); QtNetwork_PackedList { tmpValue, tmpValue->size() }; })); };
void Signal_MetaDataChanged() { callbackQNetworkReply_MetaDataChanged(this); };
void Signal_PreSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator * authenticator) { callbackQNetworkReply_PreSharedKeyAuthenticationRequired(this, authenticator); };
void Signal_RedirectAllowed() { callbackQNetworkReply_RedirectAllowed(this); };
void Signal_Redirected(const QUrl & url) { callbackQNetworkReply_Redirected(this, const_cast<QUrl*>(&url)); };
void setReadBufferSize(qint64 size) { callbackQNetworkReply_SetReadBufferSize(this, size); };
void setSslConfigurationImplementation(const QSslConfiguration & configuration) { callbackQNetworkReply_SetSslConfigurationImplementation(this, const_cast<QSslConfiguration*>(&configuration)); };
void Signal_SslErrors(const QList<QSslError> & errors) { callbackQNetworkReply_SslErrors(this, ({ QList<QSslError>* tmpValue = const_cast<QList<QSslError>*>(&errors); QtNetwork_PackedList { tmpValue, tmpValue->size() }; })); };
void Signal_SslErrors(const QList<QSslError> & erro) { callbackQNetworkReply_SslErrors(this, ({ QList<QSslError>* tmpValue = const_cast<QList<QSslError>*>(&erro); QtNetwork_PackedList { tmpValue, tmpValue->size() }; })); };
void Signal_UploadProgress(qint64 bytesSent, qint64 bytesTotal) { callbackQNetworkReply_UploadProgress(this, bytesSent, bytesTotal); };
~MyQNetworkReply() { callbackQNetworkReply_DestroyQNetworkReply(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQNetworkReply_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
@ -6245,19 +6245,19 @@ void QNetworkReply_IgnoreSslErrorsDefault(void* ptr)
static_cast<QNetworkReply*>(ptr)->QNetworkReply::ignoreSslErrors();
}
void QNetworkReply_IgnoreSslErrors2(void* ptr, void* errors)
void QNetworkReply_IgnoreSslErrors2(void* ptr, void* erro)
{
static_cast<QNetworkReply*>(ptr)->ignoreSslErrors(*static_cast<QList<QSslError>*>(errors));
static_cast<QNetworkReply*>(ptr)->ignoreSslErrors(*static_cast<QList<QSslError>*>(erro));
}
void QNetworkReply_IgnoreSslErrorsImplementation(void* ptr, void* errors)
void QNetworkReply_IgnoreSslErrorsImplementation(void* ptr, void* erro)
{
static_cast<QNetworkReply*>(ptr)->ignoreSslErrorsImplementation(*static_cast<QList<QSslError>*>(errors));
static_cast<QNetworkReply*>(ptr)->ignoreSslErrorsImplementation(*static_cast<QList<QSslError>*>(erro));
}
void QNetworkReply_IgnoreSslErrorsImplementationDefault(void* ptr, void* errors)
void QNetworkReply_IgnoreSslErrorsImplementationDefault(void* ptr, void* erro)
{
static_cast<QNetworkReply*>(ptr)->QNetworkReply::ignoreSslErrorsImplementation(*static_cast<QList<QSslError>*>(errors));
static_cast<QNetworkReply*>(ptr)->QNetworkReply::ignoreSslErrorsImplementation(*static_cast<QList<QSslError>*>(erro));
}
void QNetworkReply_ConnectMetaDataChanged(void* ptr)
@ -6395,9 +6395,9 @@ void QNetworkReply_DisconnectSslErrors(void* ptr)
QObject::disconnect(static_cast<QNetworkReply*>(ptr), static_cast<void (QNetworkReply::*)(const QList<QSslError> &)>(&QNetworkReply::sslErrors), static_cast<MyQNetworkReply*>(ptr), static_cast<void (MyQNetworkReply::*)(const QList<QSslError> &)>(&MyQNetworkReply::Signal_SslErrors));
}
void QNetworkReply_SslErrors(void* ptr, void* errors)
void QNetworkReply_SslErrors(void* ptr, void* erro)
{
static_cast<QNetworkReply*>(ptr)->sslErrors(*static_cast<QList<QSslError>*>(errors));
static_cast<QNetworkReply*>(ptr)->sslErrors(*static_cast<QList<QSslError>*>(erro));
}
void QNetworkReply_ConnectUploadProgress(void* ptr)
@ -8643,7 +8643,7 @@ public:
void resume() { callbackQAbstractSocket_Resume(this); };
void setReadBufferSize(qint64 size) { callbackQAbstractSocket_SetReadBufferSize(this, size); };
void setSocketOption(QAbstractSocket::SocketOption option, const QVariant & value) { callbackQAbstractSocket_SetSocketOption(this, option, const_cast<QVariant*>(&value)); };
void Signal_SslErrors2(const QList<QSslError> & errors) { callbackQSslSocket_SslErrors2(this, ({ QList<QSslError>* tmpValue = const_cast<QList<QSslError>*>(&errors); QtNetwork_PackedList { tmpValue, tmpValue->size() }; })); };
void Signal_SslErrors2(const QList<QSslError> & erro) { callbackQSslSocket_SslErrors2(this, ({ QList<QSslError>* tmpValue = const_cast<QList<QSslError>*>(&erro); QtNetwork_PackedList { tmpValue, tmpValue->size() }; })); };
void startClientEncryption() { callbackQSslSocket_StartClientEncryption(this); };
void startServerEncryption() { callbackQSslSocket_StartServerEncryption(this); };
~MyQSslSocket() { callbackQSslSocket_DestroyQSslSocket(this); };
@ -8839,9 +8839,9 @@ void QSslSocket_IgnoreSslErrorsDefault(void* ptr)
static_cast<QSslSocket*>(ptr)->QSslSocket::ignoreSslErrors();
}
void QSslSocket_IgnoreSslErrors2(void* ptr, void* errors)
void QSslSocket_IgnoreSslErrors2(void* ptr, void* erro)
{
static_cast<QSslSocket*>(ptr)->ignoreSslErrors(*static_cast<QList<QSslError>*>(errors));
static_cast<QSslSocket*>(ptr)->ignoreSslErrors(*static_cast<QList<QSslError>*>(erro));
}
void QSslSocket_ConnectModeChanged(void* ptr)
@ -8949,9 +8949,9 @@ void QSslSocket_DisconnectSslErrors2(void* ptr)
QObject::disconnect(static_cast<QSslSocket*>(ptr), static_cast<void (QSslSocket::*)(const QList<QSslError> &)>(&QSslSocket::sslErrors), static_cast<MyQSslSocket*>(ptr), static_cast<void (MyQSslSocket::*)(const QList<QSslError> &)>(&MyQSslSocket::Signal_SslErrors2));
}
void QSslSocket_SslErrors2(void* ptr, void* errors)
void QSslSocket_SslErrors2(void* ptr, void* erro)
{
static_cast<QSslSocket*>(ptr)->sslErrors(*static_cast<QList<QSslError>*>(errors));
static_cast<QSslSocket*>(ptr)->sslErrors(*static_cast<QList<QSslError>*>(erro));
}
void QSslSocket_StartClientEncryption(void* ptr)

116
network/network.go
View file

@ -7891,21 +7891,21 @@ func (ptr *QNetworkAccessManager) SetStrictTransportSecurityEnabled(enabled bool
}
//export callbackQNetworkAccessManager_SslErrors
func callbackQNetworkAccessManager_SslErrors(ptr unsafe.Pointer, reply unsafe.Pointer, errors C.struct_QtNetwork_PackedList) {
func callbackQNetworkAccessManager_SslErrors(ptr unsafe.Pointer, reply unsafe.Pointer, erro C.struct_QtNetwork_PackedList) {
if signal := qt.GetSignal(ptr, "sslErrors"); signal != nil {
signal.(func(*QNetworkReply, []*QSslError))(NewQNetworkReplyFromPointer(reply), func(l C.struct_QtNetwork_PackedList) []*QSslError {
out := make([]*QSslError, int(l.len))
tmpList := NewQNetworkAccessManagerFromPointer(l.data)
for i := 0; i < len(out); i++ {
out[i] = tmpList.__sslErrors_errors_atList(i)
out[i] = tmpList.__sslErrors_erro_atList(i)
}
return out
}(errors))
}(erro))
}
}
func (ptr *QNetworkAccessManager) ConnectSslErrors(f func(reply *QNetworkReply, errors []*QSslError)) {
func (ptr *QNetworkAccessManager) ConnectSslErrors(f func(reply *QNetworkReply, erro []*QSslError)) {
if ptr.Pointer() != nil {
if !qt.ExistsSignal(ptr.Pointer(), "sslErrors") {
@ -7913,9 +7913,9 @@ func (ptr *QNetworkAccessManager) ConnectSslErrors(f func(reply *QNetworkReply,
}
if signal := qt.LendSignal(ptr.Pointer(), "sslErrors"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "sslErrors", func(reply *QNetworkReply, errors []*QSslError) {
signal.(func(*QNetworkReply, []*QSslError))(reply, errors)
f(reply, errors)
qt.ConnectSignal(ptr.Pointer(), "sslErrors", func(reply *QNetworkReply, erro []*QSslError) {
signal.(func(*QNetworkReply, []*QSslError))(reply, erro)
f(reply, erro)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "sslErrors", f)
@ -7930,12 +7930,12 @@ func (ptr *QNetworkAccessManager) DisconnectSslErrors() {
}
}
func (ptr *QNetworkAccessManager) SslErrors(reply QNetworkReply_ITF, errors []*QSslError) {
func (ptr *QNetworkAccessManager) SslErrors(reply QNetworkReply_ITF, erro []*QSslError) {
if ptr.Pointer() != nil {
C.QNetworkAccessManager_SslErrors(ptr.Pointer(), PointerFromQNetworkReply(reply), func() unsafe.Pointer {
tmpList := NewQNetworkAccessManagerFromPointer(NewQNetworkAccessManagerFromPointer(nil).__sslErrors_errors_newList())
for _, v := range errors {
tmpList.__sslErrors_errors_setList(v)
tmpList := NewQNetworkAccessManagerFromPointer(NewQNetworkAccessManagerFromPointer(nil).__sslErrors_erro_newList())
for _, v := range erro {
tmpList.__sslErrors_erro_setList(v)
}
return tmpList.Pointer()
}())
@ -13043,12 +13043,12 @@ func (ptr *QNetworkReply) IgnoreSslErrorsDefault() {
}
}
func (ptr *QNetworkReply) IgnoreSslErrors2(errors []*QSslError) {
func (ptr *QNetworkReply) IgnoreSslErrors2(erro []*QSslError) {
if ptr.Pointer() != nil {
C.QNetworkReply_IgnoreSslErrors2(ptr.Pointer(), func() unsafe.Pointer {
tmpList := NewQNetworkReplyFromPointer(NewQNetworkReplyFromPointer(nil).__ignoreSslErrors_errors_newList2())
for _, v := range errors {
tmpList.__ignoreSslErrors_errors_setList2(v)
tmpList := NewQNetworkReplyFromPointer(NewQNetworkReplyFromPointer(nil).__ignoreSslErrors_erro_newList2())
for _, v := range erro {
tmpList.__ignoreSslErrors_erro_setList2(v)
}
return tmpList.Pointer()
}())
@ -13056,35 +13056,35 @@ func (ptr *QNetworkReply) IgnoreSslErrors2(errors []*QSslError) {
}
//export callbackQNetworkReply_IgnoreSslErrorsImplementation
func callbackQNetworkReply_IgnoreSslErrorsImplementation(ptr unsafe.Pointer, errors C.struct_QtNetwork_PackedList) {
func callbackQNetworkReply_IgnoreSslErrorsImplementation(ptr unsafe.Pointer, erro C.struct_QtNetwork_PackedList) {
if signal := qt.GetSignal(ptr, "ignoreSslErrorsImplementation"); signal != nil {
signal.(func([]*QSslError))(func(l C.struct_QtNetwork_PackedList) []*QSslError {
out := make([]*QSslError, int(l.len))
tmpList := NewQNetworkReplyFromPointer(l.data)
for i := 0; i < len(out); i++ {
out[i] = tmpList.__ignoreSslErrorsImplementation_errors_atList(i)
out[i] = tmpList.__ignoreSslErrorsImplementation_erro_atList(i)
}
return out
}(errors))
}(erro))
} else {
NewQNetworkReplyFromPointer(ptr).IgnoreSslErrorsImplementationDefault(func(l C.struct_QtNetwork_PackedList) []*QSslError {
out := make([]*QSslError, int(l.len))
tmpList := NewQNetworkReplyFromPointer(l.data)
for i := 0; i < len(out); i++ {
out[i] = tmpList.__ignoreSslErrorsImplementation_errors_atList(i)
out[i] = tmpList.__ignoreSslErrorsImplementation_erro_atList(i)
}
return out
}(errors))
}(erro))
}
}
func (ptr *QNetworkReply) ConnectIgnoreSslErrorsImplementation(f func(errors []*QSslError)) {
func (ptr *QNetworkReply) ConnectIgnoreSslErrorsImplementation(f func(erro []*QSslError)) {
if ptr.Pointer() != nil {
if signal := qt.LendSignal(ptr.Pointer(), "ignoreSslErrorsImplementation"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "ignoreSslErrorsImplementation", func(errors []*QSslError) {
signal.(func([]*QSslError))(errors)
f(errors)
qt.ConnectSignal(ptr.Pointer(), "ignoreSslErrorsImplementation", func(erro []*QSslError) {
signal.(func([]*QSslError))(erro)
f(erro)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "ignoreSslErrorsImplementation", f)
@ -13099,24 +13099,24 @@ func (ptr *QNetworkReply) DisconnectIgnoreSslErrorsImplementation() {
}
}
func (ptr *QNetworkReply) IgnoreSslErrorsImplementation(errors []*QSslError) {
func (ptr *QNetworkReply) IgnoreSslErrorsImplementation(erro []*QSslError) {
if ptr.Pointer() != nil {
C.QNetworkReply_IgnoreSslErrorsImplementation(ptr.Pointer(), func() unsafe.Pointer {
tmpList := NewQNetworkReplyFromPointer(NewQNetworkReplyFromPointer(nil).__ignoreSslErrorsImplementation_errors_newList())
for _, v := range errors {
tmpList.__ignoreSslErrorsImplementation_errors_setList(v)
tmpList := NewQNetworkReplyFromPointer(NewQNetworkReplyFromPointer(nil).__ignoreSslErrorsImplementation_erro_newList())
for _, v := range erro {
tmpList.__ignoreSslErrorsImplementation_erro_setList(v)
}
return tmpList.Pointer()
}())
}
}
func (ptr *QNetworkReply) IgnoreSslErrorsImplementationDefault(errors []*QSslError) {
func (ptr *QNetworkReply) IgnoreSslErrorsImplementationDefault(erro []*QSslError) {
if ptr.Pointer() != nil {
C.QNetworkReply_IgnoreSslErrorsImplementationDefault(ptr.Pointer(), func() unsafe.Pointer {
tmpList := NewQNetworkReplyFromPointer(NewQNetworkReplyFromPointer(nil).__ignoreSslErrorsImplementation_errors_newList())
for _, v := range errors {
tmpList.__ignoreSslErrorsImplementation_errors_setList(v)
tmpList := NewQNetworkReplyFromPointer(NewQNetworkReplyFromPointer(nil).__ignoreSslErrorsImplementation_erro_newList())
for _, v := range erro {
tmpList.__ignoreSslErrorsImplementation_erro_setList(v)
}
return tmpList.Pointer()
}())
@ -13423,21 +13423,21 @@ func (ptr *QNetworkReply) SetUrl(url core.QUrl_ITF) {
}
//export callbackQNetworkReply_SslErrors
func callbackQNetworkReply_SslErrors(ptr unsafe.Pointer, errors C.struct_QtNetwork_PackedList) {
func callbackQNetworkReply_SslErrors(ptr unsafe.Pointer, erro C.struct_QtNetwork_PackedList) {
if signal := qt.GetSignal(ptr, "sslErrors"); signal != nil {
signal.(func([]*QSslError))(func(l C.struct_QtNetwork_PackedList) []*QSslError {
out := make([]*QSslError, int(l.len))
tmpList := NewQNetworkReplyFromPointer(l.data)
for i := 0; i < len(out); i++ {
out[i] = tmpList.__sslErrors_errors_atList(i)
out[i] = tmpList.__sslErrors_erro_atList(i)
}
return out
}(errors))
}(erro))
}
}
func (ptr *QNetworkReply) ConnectSslErrors(f func(errors []*QSslError)) {
func (ptr *QNetworkReply) ConnectSslErrors(f func(erro []*QSslError)) {
if ptr.Pointer() != nil {
if !qt.ExistsSignal(ptr.Pointer(), "sslErrors") {
@ -13445,9 +13445,9 @@ func (ptr *QNetworkReply) ConnectSslErrors(f func(errors []*QSslError)) {
}
if signal := qt.LendSignal(ptr.Pointer(), "sslErrors"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "sslErrors", func(errors []*QSslError) {
signal.(func([]*QSslError))(errors)
f(errors)
qt.ConnectSignal(ptr.Pointer(), "sslErrors", func(erro []*QSslError) {
signal.(func([]*QSslError))(erro)
f(erro)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "sslErrors", f)
@ -13462,12 +13462,12 @@ func (ptr *QNetworkReply) DisconnectSslErrors() {
}
}
func (ptr *QNetworkReply) SslErrors(errors []*QSslError) {
func (ptr *QNetworkReply) SslErrors(erro []*QSslError) {
if ptr.Pointer() != nil {
C.QNetworkReply_SslErrors(ptr.Pointer(), func() unsafe.Pointer {
tmpList := NewQNetworkReplyFromPointer(NewQNetworkReplyFromPointer(nil).__sslErrors_errors_newList())
for _, v := range errors {
tmpList.__sslErrors_errors_setList(v)
tmpList := NewQNetworkReplyFromPointer(NewQNetworkReplyFromPointer(nil).__sslErrors_erro_newList())
for _, v := range erro {
tmpList.__sslErrors_erro_setList(v)
}
return tmpList.Pointer()
}())
@ -18754,12 +18754,12 @@ func (ptr *QSslSocket) IgnoreSslErrorsDefault() {
}
}
func (ptr *QSslSocket) IgnoreSslErrors2(errors []*QSslError) {
func (ptr *QSslSocket) IgnoreSslErrors2(erro []*QSslError) {
if ptr.Pointer() != nil {
C.QSslSocket_IgnoreSslErrors2(ptr.Pointer(), func() unsafe.Pointer {
tmpList := NewQSslSocketFromPointer(NewQSslSocketFromPointer(nil).__ignoreSslErrors_errors_newList2())
for _, v := range errors {
tmpList.__ignoreSslErrors_errors_setList2(v)
tmpList := NewQSslSocketFromPointer(NewQSslSocketFromPointer(nil).__ignoreSslErrors_erro_newList2())
for _, v := range erro {
tmpList.__ignoreSslErrors_erro_setList2(v)
}
return tmpList.Pointer()
}())
@ -18965,21 +18965,21 @@ func (ptr *QSslSocket) SetSslConfiguration(configuration QSslConfiguration_ITF)
}
//export callbackQSslSocket_SslErrors2
func callbackQSslSocket_SslErrors2(ptr unsafe.Pointer, errors C.struct_QtNetwork_PackedList) {
func callbackQSslSocket_SslErrors2(ptr unsafe.Pointer, erro C.struct_QtNetwork_PackedList) {
if signal := qt.GetSignal(ptr, "sslErrors2"); signal != nil {
signal.(func([]*QSslError))(func(l C.struct_QtNetwork_PackedList) []*QSslError {
out := make([]*QSslError, int(l.len))
tmpList := NewQSslSocketFromPointer(l.data)
for i := 0; i < len(out); i++ {
out[i] = tmpList.__sslErrors_errors_atList2(i)
out[i] = tmpList.__sslErrors_erro_atList2(i)
}
return out
}(errors))
}(erro))
}
}
func (ptr *QSslSocket) ConnectSslErrors2(f func(errors []*QSslError)) {
func (ptr *QSslSocket) ConnectSslErrors2(f func(erro []*QSslError)) {
if ptr.Pointer() != nil {
if !qt.ExistsSignal(ptr.Pointer(), "sslErrors2") {
@ -18987,9 +18987,9 @@ func (ptr *QSslSocket) ConnectSslErrors2(f func(errors []*QSslError)) {
}
if signal := qt.LendSignal(ptr.Pointer(), "sslErrors2"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "sslErrors2", func(errors []*QSslError) {
signal.(func([]*QSslError))(errors)
f(errors)
qt.ConnectSignal(ptr.Pointer(), "sslErrors2", func(erro []*QSslError) {
signal.(func([]*QSslError))(erro)
f(erro)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "sslErrors2", f)
@ -19004,12 +19004,12 @@ func (ptr *QSslSocket) DisconnectSslErrors2() {
}
}
func (ptr *QSslSocket) SslErrors2(errors []*QSslError) {
func (ptr *QSslSocket) SslErrors2(erro []*QSslError) {
if ptr.Pointer() != nil {
C.QSslSocket_SslErrors2(ptr.Pointer(), func() unsafe.Pointer {
tmpList := NewQSslSocketFromPointer(NewQSslSocketFromPointer(nil).__sslErrors_errors_newList2())
for _, v := range errors {
tmpList.__sslErrors_errors_setList2(v)
tmpList := NewQSslSocketFromPointer(NewQSslSocketFromPointer(nil).__sslErrors_erro_newList2())
for _, v := range erro {
tmpList.__sslErrors_erro_setList2(v)
}
return tmpList.Pointer()
}())

14
network/network.h
View file

@ -607,7 +607,7 @@ void QNetworkAccessManager_SetRedirectPolicy(void* ptr, long long policy);
void QNetworkAccessManager_SetStrictTransportSecurityEnabled(void* ptr, char enabled);
void QNetworkAccessManager_ConnectSslErrors(void* ptr);
void QNetworkAccessManager_DisconnectSslErrors(void* ptr);
void QNetworkAccessManager_SslErrors(void* ptr, void* reply, void* errors);
void QNetworkAccessManager_SslErrors(void* ptr, void* reply, void* erro);
void QNetworkAccessManager_DestroyQNetworkAccessManager(void* ptr);
void QNetworkAccessManager_DestroyQNetworkAccessManagerDefault(void* ptr);
void* QNetworkAccessManager_Cache(void* ptr);
@ -1007,9 +1007,9 @@ void QNetworkReply_DisconnectFinished(void* ptr);
void QNetworkReply_Finished(void* ptr);
void QNetworkReply_IgnoreSslErrors(void* ptr);
void QNetworkReply_IgnoreSslErrorsDefault(void* ptr);
void QNetworkReply_IgnoreSslErrors2(void* ptr, void* errors);
void QNetworkReply_IgnoreSslErrorsImplementation(void* ptr, void* errors);
void QNetworkReply_IgnoreSslErrorsImplementationDefault(void* ptr, void* errors);
void QNetworkReply_IgnoreSslErrors2(void* ptr, void* erro);
void QNetworkReply_IgnoreSslErrorsImplementation(void* ptr, void* erro);
void QNetworkReply_IgnoreSslErrorsImplementationDefault(void* ptr, void* erro);
void QNetworkReply_ConnectMetaDataChanged(void* ptr);
void QNetworkReply_DisconnectMetaDataChanged(void* ptr);
void QNetworkReply_MetaDataChanged(void* ptr);
@ -1037,7 +1037,7 @@ void QNetworkReply_SetSslConfigurationImplementationDefault(void* ptr, void* con
void QNetworkReply_SetUrl(void* ptr, void* url);
void QNetworkReply_ConnectSslErrors(void* ptr);
void QNetworkReply_DisconnectSslErrors(void* ptr);
void QNetworkReply_SslErrors(void* ptr, void* errors);
void QNetworkReply_SslErrors(void* ptr, void* erro);
void QNetworkReply_ConnectUploadProgress(void* ptr);
void QNetworkReply_DisconnectUploadProgress(void* ptr);
void QNetworkReply_UploadProgress(void* ptr, long long bytesSent, long long bytesTotal);
@ -1481,7 +1481,7 @@ void QSslSocket_DisconnectEncryptedBytesWritten(void* ptr);
void QSslSocket_EncryptedBytesWritten(void* ptr, long long written);
void QSslSocket_IgnoreSslErrors(void* ptr);
void QSslSocket_IgnoreSslErrorsDefault(void* ptr);
void QSslSocket_IgnoreSslErrors2(void* ptr, void* errors);
void QSslSocket_IgnoreSslErrors2(void* ptr, void* erro);
void QSslSocket_ConnectModeChanged(void* ptr);
void QSslSocket_DisconnectModeChanged(void* ptr);
void QSslSocket_ModeChanged(void* ptr, long long mode);
@ -1503,7 +1503,7 @@ void QSslSocket_SetProtocol(void* ptr, long long protocol);
void QSslSocket_SetSslConfiguration(void* ptr, void* configuration);
void QSslSocket_ConnectSslErrors2(void* ptr);
void QSslSocket_DisconnectSslErrors2(void* ptr);
void QSslSocket_SslErrors2(void* ptr, void* errors);
void QSslSocket_SslErrors2(void* ptr, void* erro);
void QSslSocket_StartClientEncryption(void* ptr);
void QSslSocket_StartClientEncryptionDefault(void* ptr);
void QSslSocket_StartServerEncryption(void* ptr);

4
qml/qml.cpp
View file

@ -1846,9 +1846,9 @@ long long QQmlEngine_QQmlEngine_ObjectOwnership(void* object)
return QQmlEngine::objectOwnership(static_cast<QObject*>(object));
}
char QQmlEngine_ImportPlugin(void* ptr, struct QtQml_PackedString filePath, struct QtQml_PackedString uri, void* errors)
char QQmlEngine_ImportPlugin(void* ptr, struct QtQml_PackedString filePath, struct QtQml_PackedString uri, void* erro)
{
return static_cast<QQmlEngine*>(ptr)->importPlugin(QString::fromUtf8(filePath.data, filePath.len), QString::fromUtf8(uri.data, uri.len), static_cast<QList<QQmlError>*>(errors));
return static_cast<QQmlEngine*>(ptr)->importPlugin(QString::fromUtf8(filePath.data, filePath.len), QString::fromUtf8(uri.data, uri.len), static_cast<QList<QQmlError>*>(erro));
}
void QQmlEngine_AddImageProvider(void* ptr, struct QtQml_PackedString providerId, void* provider)

8
qml/qml.go
View file

@ -3080,7 +3080,7 @@ func (ptr *QQmlEngine) ObjectOwnership(object core.QObject_ITF) QQmlEngine__Obje
return QQmlEngine__ObjectOwnership(C.QQmlEngine_QQmlEngine_ObjectOwnership(core.PointerFromQObject(object)))
}
func (ptr *QQmlEngine) ImportPlugin(filePath string, uri string, errors []*QQmlError) bool {
func (ptr *QQmlEngine) ImportPlugin(filePath string, uri string, erro []*QQmlError) bool {
if ptr.Pointer() != nil {
var filePathC *C.char
if filePath != "" {
@ -3093,9 +3093,9 @@ func (ptr *QQmlEngine) ImportPlugin(filePath string, uri string, errors []*QQmlE
defer C.free(unsafe.Pointer(uriC))
}
return int8(C.QQmlEngine_ImportPlugin(ptr.Pointer(), C.struct_QtQml_PackedString{data: filePathC, len: C.longlong(len(filePath))}, C.struct_QtQml_PackedString{data: uriC, len: C.longlong(len(uri))}, func() unsafe.Pointer {
tmpList := NewQQmlEngineFromPointer(NewQQmlEngineFromPointer(nil).__importPlugin_errors_newList())
for _, v := range errors {
tmpList.__importPlugin_errors_setList(v)
tmpList := NewQQmlEngineFromPointer(NewQQmlEngineFromPointer(nil).__importPlugin_erro_newList())
for _, v := range erro {
tmpList.__importPlugin_erro_setList(v)
}
return tmpList.Pointer()
}())) != 0

2
qml/qml.h
View file

@ -252,7 +252,7 @@ void QQmlContext_TimerEventDefault(void* ptr, void* event);
void* QQmlEngine_QQmlEngine_ContextForObject(void* object);
void* QQmlEngine_NewQQmlEngine(void* parent);
long long QQmlEngine_QQmlEngine_ObjectOwnership(void* object);
char QQmlEngine_ImportPlugin(void* ptr, struct QtQml_PackedString filePath, struct QtQml_PackedString uri, void* errors);
char QQmlEngine_ImportPlugin(void* ptr, struct QtQml_PackedString filePath, struct QtQml_PackedString uri, void* erro);
void QQmlEngine_AddImageProvider(void* ptr, struct QtQml_PackedString providerId, void* provider);
void QQmlEngine_AddImportPath(void* ptr, struct QtQml_PackedString path);
void QQmlEngine_AddPluginPath(void* ptr, struct QtQml_PackedString path);

7
qt_js.go
View file

@ -4,7 +4,8 @@ package qt
import "github.com/gopherjs/gopherjs/js"
var WASM = js.Global.Call("eval", "Module")
var Global = js.Global
var Module = Global.Call("eval", "Module")
func MakeWrapper(i interface{}) *js.Object {
o := js.InternalObject(i)
@ -22,3 +23,7 @@ func MakeWrapper(i interface{}) *js.Object {
}
return o
}
//
var WASM = Module //TODO: remove

11
qt_notjs.go Normal file
View file

@ -0,0 +1,11 @@
// +build !js
package qt
type jsValue interface {
Call(...string) jsValue
Int() int
}
var Global jsValue
var Module jsValue

11
qt_wasm.go
View file

@ -7,11 +7,18 @@ import (
"unsafe"
)
var WASM = js.Global().Call("eval", "Module")
func init() {
WASM.Set("_callbackReleaseTypedArray", js.NewCallback(func(_ js.Value, args []js.Value) interface{} {
(*js.TypedArray)(unsafe.Pointer(uintptr(args[0].Int()))).Release()
return nil
}))
}
var Global = js.Global()
var Module = Global.Call("eval", "Module")
//TODO: func MakeWrapper(i interface{}) *js.Value
//
var WASM = Module //TODO: remove

8
quick/quick.cpp
View file

@ -6519,14 +6519,14 @@ void QSGNode_RemoveChildNode(void* ptr, void* node)
static_cast<QSGNode*>(ptr)->removeChildNode(static_cast<QSGNode*>(node));
}
void QSGNode_SetFlag(void* ptr, long long fo, char enabled)
void QSGNode_SetFlag(void* ptr, long long ff, char enabled)
{
static_cast<QSGNode*>(ptr)->setFlag(static_cast<QSGNode::Flag>(fo), enabled != 0);
static_cast<QSGNode*>(ptr)->setFlag(static_cast<QSGNode::Flag>(ff), enabled != 0);
}
void QSGNode_SetFlags(void* ptr, long long fo, char enabled)
void QSGNode_SetFlags(void* ptr, long long ff, char enabled)
{
static_cast<QSGNode*>(ptr)->setFlags(static_cast<QSGNode::Flag>(fo), enabled != 0);
static_cast<QSGNode*>(ptr)->setFlags(static_cast<QSGNode::Flag>(ff), enabled != 0);
}
void QSGNode_DestroyQSGNode(void* ptr)

8
quick/quick.go
View file

@ -13959,15 +13959,15 @@ func (ptr *QSGNode) RemoveChildNode(node QSGNode_ITF) {
}
}
func (ptr *QSGNode) SetFlag(fo QSGNode__Flag, enabled bool) {
func (ptr *QSGNode) SetFlag(ff QSGNode__Flag, enabled bool) {
if ptr.Pointer() != nil {
C.QSGNode_SetFlag(ptr.Pointer(), C.longlong(fo), C.char(int8(qt.GoBoolToInt(enabled))))
C.QSGNode_SetFlag(ptr.Pointer(), C.longlong(ff), C.char(int8(qt.GoBoolToInt(enabled))))
}
}
func (ptr *QSGNode) SetFlags(fo QSGNode__Flag, enabled bool) {
func (ptr *QSGNode) SetFlags(ff QSGNode__Flag, enabled bool) {
if ptr.Pointer() != nil {
C.QSGNode_SetFlags(ptr.Pointer(), C.longlong(fo), C.char(int8(qt.GoBoolToInt(enabled))))
C.QSGNode_SetFlags(ptr.Pointer(), C.longlong(ff), C.char(int8(qt.GoBoolToInt(enabled))))
}
}

4
quick/quick.h
View file

@ -975,8 +975,8 @@ void QSGNode_Preprocess(void* ptr);
void QSGNode_PreprocessDefault(void* ptr);
void QSGNode_RemoveAllChildNodes(void* ptr);
void QSGNode_RemoveChildNode(void* ptr, void* node);
void QSGNode_SetFlag(void* ptr, long long fo, char enabled);
void QSGNode_SetFlags(void* ptr, long long fo, char enabled);
void QSGNode_SetFlag(void* ptr, long long ff, char enabled);
void QSGNode_SetFlags(void* ptr, long long ff, char enabled);
void QSGNode_DestroyQSGNode(void* ptr);
void QSGNode_DestroyQSGNodeDefault(void* ptr);
void* QSGNode_ChildAtIndex(void* ptr, int i);

16
websockets/websockets.cpp
View file

@ -274,7 +274,7 @@ public:
void Signal_PreSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator * authenticator) { callbackQWebSocket_PreSharedKeyAuthenticationRequired(this, authenticator); };
void Signal_ProxyAuthenticationRequired(const QNetworkProxy & proxy, QAuthenticator * authenticator) { callbackQWebSocket_ProxyAuthenticationRequired(this, const_cast<QNetworkProxy*>(&proxy), authenticator); };
void Signal_ReadChannelFinished() { callbackQWebSocket_ReadChannelFinished(this); };
void Signal_SslErrors(const QList<QSslError> & errors) { callbackQWebSocket_SslErrors(this, ({ QList<QSslError>* tmpValue = const_cast<QList<QSslError>*>(&errors); QtWebSockets_PackedList { tmpValue, tmpValue->size() }; })); };
void Signal_SslErrors(const QList<QSslError> & erro) { callbackQWebSocket_SslErrors(this, ({ QList<QSslError>* tmpValue = const_cast<QList<QSslError>*>(&erro); QtWebSockets_PackedList { tmpValue, tmpValue->size() }; })); };
void Signal_StateChanged(QAbstractSocket::SocketState state) { callbackQWebSocket_StateChanged(this, state); };
void Signal_TextFrameReceived(const QString & frame, bool isLastFrame) { QByteArray t39d88b = frame.toUtf8(); QtWebSockets_PackedString framePacked = { const_cast<char*>(t39d88b.prepend("WHITESPACE").constData()+10), t39d88b.size()-10 };callbackQWebSocket_TextFrameReceived(this, framePacked, isLastFrame); };
void Signal_TextMessageReceived(const QString & message) { QByteArray t6f9b9a = message.toUtf8(); QtWebSockets_PackedString messagePacked = { const_cast<char*>(t6f9b9a.prepend("WHITESPACE").constData()+10), t6f9b9a.size()-10 };callbackQWebSocket_TextMessageReceived(this, messagePacked); };
@ -491,9 +491,9 @@ void QWebSocket_IgnoreSslErrorsDefault(void* ptr)
static_cast<QWebSocket*>(ptr)->QWebSocket::ignoreSslErrors();
}
void QWebSocket_IgnoreSslErrors2(void* ptr, void* errors)
void QWebSocket_IgnoreSslErrors2(void* ptr, void* erro)
{
static_cast<QWebSocket*>(ptr)->ignoreSslErrors(*static_cast<QList<QSslError>*>(errors));
static_cast<QWebSocket*>(ptr)->ignoreSslErrors(*static_cast<QList<QSslError>*>(erro));
}
void QWebSocket_Open2(void* ptr, void* request)
@ -626,9 +626,9 @@ void QWebSocket_DisconnectSslErrors(void* ptr)
QObject::disconnect(static_cast<QWebSocket*>(ptr), static_cast<void (QWebSocket::*)(const QList<QSslError> &)>(&QWebSocket::sslErrors), static_cast<MyQWebSocket*>(ptr), static_cast<void (MyQWebSocket::*)(const QList<QSslError> &)>(&MyQWebSocket::Signal_SslErrors));
}
void QWebSocket_SslErrors(void* ptr, void* errors)
void QWebSocket_SslErrors(void* ptr, void* erro)
{
static_cast<QWebSocket*>(ptr)->sslErrors(*static_cast<QList<QSslError>*>(errors));
static_cast<QWebSocket*>(ptr)->sslErrors(*static_cast<QList<QSslError>*>(erro));
}
void QWebSocket_ConnectStateChanged(void* ptr)
@ -1002,7 +1002,7 @@ public:
void Signal_PeerVerifyError(const QSslError & error) { callbackQWebSocketServer_PeerVerifyError(this, const_cast<QSslError*>(&error)); };
void Signal_PreSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator * authenticator) { callbackQWebSocketServer_PreSharedKeyAuthenticationRequired(this, authenticator); };
void Signal_ServerError(QWebSocketProtocol::CloseCode closeCode) { callbackQWebSocketServer_ServerError(this, closeCode); };
void Signal_SslErrors(const QList<QSslError> & errors) { callbackQWebSocketServer_SslErrors(this, ({ QList<QSslError>* tmpValue = const_cast<QList<QSslError>*>(&errors); QtWebSockets_PackedList { tmpValue, tmpValue->size() }; })); };
void Signal_SslErrors(const QList<QSslError> & erro) { callbackQWebSocketServer_SslErrors(this, ({ QList<QSslError>* tmpValue = const_cast<QList<QSslError>*>(&erro); QtWebSockets_PackedList { tmpValue, tmpValue->size() }; })); };
~MyQWebSocketServer() { callbackQWebSocketServer_DestroyQWebSocketServer(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWebSocketServer_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * e) { return callbackQWebSocketServer_Event(this, e) != 0; };
@ -1241,9 +1241,9 @@ void QWebSocketServer_DisconnectSslErrors(void* ptr)
QObject::disconnect(static_cast<QWebSocketServer*>(ptr), static_cast<void (QWebSocketServer::*)(const QList<QSslError> &)>(&QWebSocketServer::sslErrors), static_cast<MyQWebSocketServer*>(ptr), static_cast<void (MyQWebSocketServer::*)(const QList<QSslError> &)>(&MyQWebSocketServer::Signal_SslErrors));
}
void QWebSocketServer_SslErrors(void* ptr, void* errors)
void QWebSocketServer_SslErrors(void* ptr, void* erro)
{
static_cast<QWebSocketServer*>(ptr)->sslErrors(*static_cast<QList<QSslError>*>(errors));
static_cast<QWebSocketServer*>(ptr)->sslErrors(*static_cast<QList<QSslError>*>(erro));
}
void QWebSocketServer_DestroyQWebSocketServer(void* ptr)

52
websockets/websockets.go
View file

@ -953,12 +953,12 @@ func (ptr *QWebSocket) IgnoreSslErrorsDefault() {
}
}
func (ptr *QWebSocket) IgnoreSslErrors2(errors []*network.QSslError) {
func (ptr *QWebSocket) IgnoreSslErrors2(erro []*network.QSslError) {
if ptr.Pointer() != nil {
C.QWebSocket_IgnoreSslErrors2(ptr.Pointer(), func() unsafe.Pointer {
tmpList := NewQWebSocketFromPointer(NewQWebSocketFromPointer(nil).__ignoreSslErrors_errors_newList2())
for _, v := range errors {
tmpList.__ignoreSslErrors_errors_setList2(v)
tmpList := NewQWebSocketFromPointer(NewQWebSocketFromPointer(nil).__ignoreSslErrors_erro_newList2())
for _, v := range erro {
tmpList.__ignoreSslErrors_erro_setList2(v)
}
return tmpList.Pointer()
}())
@ -1284,21 +1284,21 @@ func (ptr *QWebSocket) SetSslConfiguration(sslConfiguration network.QSslConfigur
}
//export callbackQWebSocket_SslErrors
func callbackQWebSocket_SslErrors(ptr unsafe.Pointer, errors C.struct_QtWebSockets_PackedList) {
func callbackQWebSocket_SslErrors(ptr unsafe.Pointer, erro C.struct_QtWebSockets_PackedList) {
if signal := qt.GetSignal(ptr, "sslErrors"); signal != nil {
signal.(func([]*network.QSslError))(func(l C.struct_QtWebSockets_PackedList) []*network.QSslError {
out := make([]*network.QSslError, int(l.len))
tmpList := NewQWebSocketFromPointer(l.data)
for i := 0; i < len(out); i++ {
out[i] = tmpList.__sslErrors_errors_atList(i)
out[i] = tmpList.__sslErrors_erro_atList(i)
}
return out
}(errors))
}(erro))
}
}
func (ptr *QWebSocket) ConnectSslErrors(f func(errors []*network.QSslError)) {
func (ptr *QWebSocket) ConnectSslErrors(f func(erro []*network.QSslError)) {
if ptr.Pointer() != nil {
if !qt.ExistsSignal(ptr.Pointer(), "sslErrors") {
@ -1306,9 +1306,9 @@ func (ptr *QWebSocket) ConnectSslErrors(f func(errors []*network.QSslError)) {
}
if signal := qt.LendSignal(ptr.Pointer(), "sslErrors"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "sslErrors", func(errors []*network.QSslError) {
signal.(func([]*network.QSslError))(errors)
f(errors)
qt.ConnectSignal(ptr.Pointer(), "sslErrors", func(erro []*network.QSslError) {
signal.(func([]*network.QSslError))(erro)
f(erro)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "sslErrors", f)
@ -1323,12 +1323,12 @@ func (ptr *QWebSocket) DisconnectSslErrors() {
}
}
func (ptr *QWebSocket) SslErrors(errors []*network.QSslError) {
func (ptr *QWebSocket) SslErrors(erro []*network.QSslError) {
if ptr.Pointer() != nil {
C.QWebSocket_SslErrors(ptr.Pointer(), func() unsafe.Pointer {
tmpList := NewQWebSocketFromPointer(NewQWebSocketFromPointer(nil).__sslErrors_errors_newList())
for _, v := range errors {
tmpList.__sslErrors_errors_setList(v)
tmpList := NewQWebSocketFromPointer(NewQWebSocketFromPointer(nil).__sslErrors_erro_newList())
for _, v := range erro {
tmpList.__sslErrors_erro_setList(v)
}
return tmpList.Pointer()
}())
@ -2648,21 +2648,21 @@ func (ptr *QWebSocketServer) SetSslConfiguration(sslConfiguration network.QSslCo
}
//export callbackQWebSocketServer_SslErrors
func callbackQWebSocketServer_SslErrors(ptr unsafe.Pointer, errors C.struct_QtWebSockets_PackedList) {
func callbackQWebSocketServer_SslErrors(ptr unsafe.Pointer, erro C.struct_QtWebSockets_PackedList) {
if signal := qt.GetSignal(ptr, "sslErrors"); signal != nil {
signal.(func([]*network.QSslError))(func(l C.struct_QtWebSockets_PackedList) []*network.QSslError {
out := make([]*network.QSslError, int(l.len))
tmpList := NewQWebSocketServerFromPointer(l.data)
for i := 0; i < len(out); i++ {
out[i] = tmpList.__sslErrors_errors_atList(i)
out[i] = tmpList.__sslErrors_erro_atList(i)
}
return out
}(errors))
}(erro))
}
}
func (ptr *QWebSocketServer) ConnectSslErrors(f func(errors []*network.QSslError)) {
func (ptr *QWebSocketServer) ConnectSslErrors(f func(erro []*network.QSslError)) {
if ptr.Pointer() != nil {
if !qt.ExistsSignal(ptr.Pointer(), "sslErrors") {
@ -2670,9 +2670,9 @@ func (ptr *QWebSocketServer) ConnectSslErrors(f func(errors []*network.QSslError
}
if signal := qt.LendSignal(ptr.Pointer(), "sslErrors"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "sslErrors", func(errors []*network.QSslError) {
signal.(func([]*network.QSslError))(errors)
f(errors)
qt.ConnectSignal(ptr.Pointer(), "sslErrors", func(erro []*network.QSslError) {
signal.(func([]*network.QSslError))(erro)
f(erro)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "sslErrors", f)
@ -2687,12 +2687,12 @@ func (ptr *QWebSocketServer) DisconnectSslErrors() {
}
}
func (ptr *QWebSocketServer) SslErrors(errors []*network.QSslError) {
func (ptr *QWebSocketServer) SslErrors(erro []*network.QSslError) {
if ptr.Pointer() != nil {
C.QWebSocketServer_SslErrors(ptr.Pointer(), func() unsafe.Pointer {
tmpList := NewQWebSocketServerFromPointer(NewQWebSocketServerFromPointer(nil).__sslErrors_errors_newList())
for _, v := range errors {
tmpList.__sslErrors_errors_setList(v)
tmpList := NewQWebSocketServerFromPointer(NewQWebSocketServerFromPointer(nil).__sslErrors_erro_newList())
for _, v := range erro {
tmpList.__sslErrors_erro_setList(v)
}
return tmpList.Pointer()
}())

6
websockets/websockets.h
View file

@ -77,7 +77,7 @@ void QWebSocket_DisconnectError2(void* ptr);
void QWebSocket_Error2(void* ptr, long long error);
void QWebSocket_IgnoreSslErrors(void* ptr);
void QWebSocket_IgnoreSslErrorsDefault(void* ptr);
void QWebSocket_IgnoreSslErrors2(void* ptr, void* errors);
void QWebSocket_IgnoreSslErrors2(void* ptr, void* erro);
void QWebSocket_Open2(void* ptr, void* request);
void QWebSocket_Open2Default(void* ptr, void* request);
void QWebSocket_Open(void* ptr, void* url);
@ -104,7 +104,7 @@ void QWebSocket_SetReadBufferSize(void* ptr, long long size);
void QWebSocket_SetSslConfiguration(void* ptr, void* sslConfiguration);
void QWebSocket_ConnectSslErrors(void* ptr);
void QWebSocket_DisconnectSslErrors(void* ptr);
void QWebSocket_SslErrors(void* ptr, void* errors);
void QWebSocket_SslErrors(void* ptr, void* erro);
void QWebSocket_ConnectStateChanged(void* ptr);
void QWebSocket_DisconnectStateChanged(void* ptr);
void QWebSocket_StateChanged(void* ptr, long long state);
@ -212,7 +212,7 @@ void QWebSocketServer_SetServerName(void* ptr, struct QtWebSockets_PackedString
void QWebSocketServer_SetSslConfiguration(void* ptr, void* sslConfiguration);
void QWebSocketServer_ConnectSslErrors(void* ptr);
void QWebSocketServer_DisconnectSslErrors(void* ptr);
void QWebSocketServer_SslErrors(void* ptr, void* errors);
void QWebSocketServer_SslErrors(void* ptr, void* erro);
void QWebSocketServer_DestroyQWebSocketServer(void* ptr);
void QWebSocketServer_DestroyQWebSocketServerDefault(void* ptr);
void* QWebSocketServer_ServerAddress(void* ptr);

148
widgets/widgets.cpp
View file

@ -10377,9 +10377,9 @@ public:
void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
void setDate(const QDate & date) { callbackQDateTimeEdit_SetDate(this, const_cast<QDate*>(&date)); };
void setDateTime(const QDateTime & dateTime) { callbackQDateTimeEdit_SetDateTime(this, const_cast<QDateTime*>(&dateTime)); };
void setTime(const QTime & time) { callbackQDateTimeEdit_SetTime(this, const_cast<QTime*>(&time)); };
void setTime(const QTime & ti) { callbackQDateTimeEdit_SetTime(this, const_cast<QTime*>(&ti)); };
void stepBy(int steps) { callbackQAbstractSpinBox_StepBy(this, steps); };
void Signal_TimeChanged(const QTime & time) { callbackQDateTimeEdit_TimeChanged(this, const_cast<QTime*>(&time)); };
void Signal_TimeChanged(const QTime & ti) { callbackQDateTimeEdit_TimeChanged(this, const_cast<QTime*>(&ti)); };
void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
QAbstractSpinBox::StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQAbstractSpinBox_StepEnabled(const_cast<void*>(static_cast<const void*>(this)))); };
QDateTime dateTimeFromText(const QString & text) const { QByteArray t372ea0 = text.toUtf8(); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };return *static_cast<QDateTime*>(callbackQDateTimeEdit_DateTimeFromText(const_cast<void*>(static_cast<const void*>(this)), textPacked)); };
@ -10484,7 +10484,7 @@ public:
MyQDateTimeEdit(QWidget *parent = Q_NULLPTR) : QDateTimeEdit(parent) {QDateTimeEdit_QDateTimeEdit_QRegisterMetaType();};
MyQDateTimeEdit(const QDate &date, QWidget *parent = Q_NULLPTR) : QDateTimeEdit(date, parent) {QDateTimeEdit_QDateTimeEdit_QRegisterMetaType();};
MyQDateTimeEdit(const QDateTime &datetime, QWidget *parent = Q_NULLPTR) : QDateTimeEdit(datetime, parent) {QDateTimeEdit_QDateTimeEdit_QRegisterMetaType();};
MyQDateTimeEdit(const QTime &time, QWidget *parent = Q_NULLPTR) : QDateTimeEdit(time, parent) {QDateTimeEdit_QDateTimeEdit_QRegisterMetaType();};
MyQDateTimeEdit(const QTime &ti, QWidget *parent = Q_NULLPTR) : QDateTimeEdit(ti, parent) {QDateTimeEdit_QDateTimeEdit_QRegisterMetaType();};
bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
void clear() { callbackQDateTimeEdit_Clear(this); };
@ -10496,9 +10496,9 @@ public:
void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
void setDate(const QDate & date) { callbackQDateTimeEdit_SetDate(this, const_cast<QDate*>(&date)); };
void setDateTime(const QDateTime & dateTime) { callbackQDateTimeEdit_SetDateTime(this, const_cast<QDateTime*>(&dateTime)); };
void setTime(const QTime & time) { callbackQDateTimeEdit_SetTime(this, const_cast<QTime*>(&time)); };
void setTime(const QTime & ti) { callbackQDateTimeEdit_SetTime(this, const_cast<QTime*>(&ti)); };
void stepBy(int steps) { callbackQAbstractSpinBox_StepBy(this, steps); };
void Signal_TimeChanged(const QTime & time) { callbackQDateTimeEdit_TimeChanged(this, const_cast<QTime*>(&time)); };
void Signal_TimeChanged(const QTime & ti) { callbackQDateTimeEdit_TimeChanged(this, const_cast<QTime*>(&ti)); };
void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
~MyQDateTimeEdit() { callbackQDateTimeEdit_DestroyQDateTimeEdit(this); };
QAbstractSpinBox::StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQAbstractSpinBox_StepEnabled(const_cast<void*>(static_cast<const void*>(this)))); };
@ -10593,9 +10593,9 @@ void* QDateTimeEdit_NewQDateTimeEdit2(void* datetime, void* parent)
return new MyQDateTimeEdit(*static_cast<QDateTime*>(datetime), static_cast<QWidget*>(parent));
}
void* QDateTimeEdit_NewQDateTimeEdit4(void* time, void* parent)
void* QDateTimeEdit_NewQDateTimeEdit4(void* ti, void* parent)
{
return new MyQDateTimeEdit(*static_cast<QTime*>(time), static_cast<QWidget*>(parent));
return new MyQDateTimeEdit(*static_cast<QTime*>(ti), static_cast<QWidget*>(parent));
}
void QDateTimeEdit_Clear(void* ptr)
@ -10776,19 +10776,19 @@ void QDateTimeEdit_SetSelectedSection(void* ptr, long long section)
static_cast<QDateTimeEdit*>(ptr)->setSelectedSection(static_cast<QDateTimeEdit::Section>(section));
}
void QDateTimeEdit_SetTime(void* ptr, void* time)
void QDateTimeEdit_SetTime(void* ptr, void* ti)
{
QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setTime", Q_ARG(const QTime, *static_cast<QTime*>(time)));
QMetaObject::invokeMethod(static_cast<QDateTimeEdit*>(ptr), "setTime", Q_ARG(const QTime, *static_cast<QTime*>(ti)));
}
void QDateTimeEdit_SetTimeDefault(void* ptr, void* time)
void QDateTimeEdit_SetTimeDefault(void* ptr, void* ti)
{
if (dynamic_cast<QTimeEdit*>(static_cast<QObject*>(ptr))) {
static_cast<QTimeEdit*>(ptr)->QTimeEdit::setTime(*static_cast<QTime*>(time));
static_cast<QTimeEdit*>(ptr)->QTimeEdit::setTime(*static_cast<QTime*>(ti));
} else if (dynamic_cast<QDateEdit*>(static_cast<QObject*>(ptr))) {
static_cast<QDateEdit*>(ptr)->QDateEdit::setTime(*static_cast<QTime*>(time));
static_cast<QDateEdit*>(ptr)->QDateEdit::setTime(*static_cast<QTime*>(ti));
} else {
static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setTime(*static_cast<QTime*>(time));
static_cast<QDateTimeEdit*>(ptr)->QDateTimeEdit::setTime(*static_cast<QTime*>(ti));
}
}
@ -10812,9 +10812,9 @@ void QDateTimeEdit_DisconnectTimeChanged(void* ptr)
QObject::disconnect(static_cast<QDateTimeEdit*>(ptr), static_cast<void (QDateTimeEdit::*)(const QTime &)>(&QDateTimeEdit::timeChanged), static_cast<MyQDateTimeEdit*>(ptr), static_cast<void (MyQDateTimeEdit::*)(const QTime &)>(&MyQDateTimeEdit::Signal_TimeChanged));
}
void QDateTimeEdit_TimeChanged(void* ptr, void* time)
void QDateTimeEdit_TimeChanged(void* ptr, void* ti)
{
static_cast<QDateTimeEdit*>(ptr)->timeChanged(*static_cast<QTime*>(time));
static_cast<QDateTimeEdit*>(ptr)->timeChanged(*static_cast<QTime*>(ti));
}
void QDateTimeEdit_DestroyQDateTimeEdit(void* ptr)
@ -11313,7 +11313,7 @@ void QDial_InitStyleOption(void* ptr, void* option)
class MyQDialog: public QDialog
{
public:
MyQDialog(QWidget *parent = Q_NULLPTR, Qt::WindowFlags fo = Qt::WindowFlags()) : QDialog(parent, fo) {QDialog_QDialog_QRegisterMetaType();};
MyQDialog(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QDialog(parent, ff) {QDialog_QDialog_QRegisterMetaType();};
bool eventFilter(QObject * o, QEvent * e) { return callbackQWidget_EventFilter(this, o, e) != 0; };
int exec() { return callbackQDialog_Exec(this); };
void accept() { callbackQDialog_Accept(this); };
@ -11398,9 +11398,9 @@ Q_DECLARE_METATYPE(MyQDialog*)
int QDialog_QDialog_QRegisterMetaType(){qRegisterMetaType<QDialog*>(); return qRegisterMetaType<MyQDialog*>();}
void* QDialog_NewQDialog(void* parent, long long fo)
void* QDialog_NewQDialog(void* parent, long long ff)
{
return new MyQDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
return new MyQDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}
int QDialog_Exec(void* ptr)
@ -15370,7 +15370,7 @@ public:
MyQFontComboBox(QWidget *parent = Q_NULLPTR) : QFontComboBox(parent) {QFontComboBox_QFontComboBox_QRegisterMetaType();};
bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
void Signal_CurrentFontChanged(const QFont & font) { callbackQFontComboBox_CurrentFontChanged(this, const_cast<QFont*>(&font)); };
void setCurrentFont(const QFont & fo) { callbackQFontComboBox_SetCurrentFont(this, const_cast<QFont*>(&fo)); };
void setCurrentFont(const QFont & ff) { callbackQFontComboBox_SetCurrentFont(this, const_cast<QFont*>(&ff)); };
~MyQFontComboBox() { callbackQFontComboBox_DestroyQFontComboBox(this); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
@ -15481,14 +15481,14 @@ void QFontComboBox_CurrentFontChanged(void* ptr, void* font)
static_cast<QFontComboBox*>(ptr)->currentFontChanged(*static_cast<QFont*>(font));
}
void QFontComboBox_SetCurrentFont(void* ptr, void* fo)
void QFontComboBox_SetCurrentFont(void* ptr, void* ff)
{
QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setCurrentFont", Q_ARG(const QFont, *static_cast<QFont*>(fo)));
QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setCurrentFont", Q_ARG(const QFont, *static_cast<QFont*>(ff)));
}
void QFontComboBox_SetCurrentFontDefault(void* ptr, void* fo)
void QFontComboBox_SetCurrentFontDefault(void* ptr, void* ff)
{
static_cast<QFontComboBox*>(ptr)->QFontComboBox::setCurrentFont(*static_cast<QFont*>(fo));
static_cast<QFontComboBox*>(ptr)->QFontComboBox::setCurrentFont(*static_cast<QFont*>(ff));
}
void QFontComboBox_SetFontFilters(void* ptr, long long filters)
@ -16002,7 +16002,7 @@ int QFormLayout_VerticalSpacing(void* ptr)
class MyQFrame: public QFrame
{
public:
MyQFrame(QWidget *parent = Q_NULLPTR, Qt::WindowFlags fo = Qt::WindowFlags()) : QFrame(parent, fo) {QFrame_QFrame_QRegisterMetaType();};
MyQFrame(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QFrame(parent, ff) {QFrame_QFrame_QRegisterMetaType();};
bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
void paintEvent(QPaintEvent * vqp) { callbackQWidget_PaintEvent(this, vqp); };
@ -16079,9 +16079,9 @@ Q_DECLARE_METATYPE(MyQFrame*)
int QFrame_QFrame_QRegisterMetaType(){qRegisterMetaType<QFrame*>(); return qRegisterMetaType<MyQFrame*>();}
void* QFrame_NewQFrame(void* parent, long long fo)
void* QFrame_NewQFrame(void* parent, long long ff)
{
return new MyQFrame(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
return new MyQFrame(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}
void QFrame_SetFrameRect(void* ptr, void* vqr)
@ -33512,8 +33512,8 @@ int QLCDNumber_IntValue(void* ptr)
class MyQLabel: public QLabel
{
public:
MyQLabel(QWidget *parent = Q_NULLPTR, Qt::WindowFlags fo = Qt::WindowFlags()) : QLabel(parent, fo) {QLabel_QLabel_QRegisterMetaType();};
MyQLabel(const QString &text, QWidget *parent = Q_NULLPTR, Qt::WindowFlags fo = Qt::WindowFlags()) : QLabel(text, parent, fo) {QLabel_QLabel_QRegisterMetaType();};
MyQLabel(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QLabel(parent, ff) {QLabel_QLabel_QRegisterMetaType();};
MyQLabel(const QString &text, QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QLabel(text, parent, ff) {QLabel_QLabel_QRegisterMetaType();};
bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
@ -33599,14 +33599,14 @@ Q_DECLARE_METATYPE(MyQLabel*)
int QLabel_QLabel_QRegisterMetaType(){qRegisterMetaType<QLabel*>(); return qRegisterMetaType<MyQLabel*>();}
void* QLabel_NewQLabel(void* parent, long long fo)
void* QLabel_NewQLabel(void* parent, long long ff)
{
return new MyQLabel(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
return new MyQLabel(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}
void* QLabel_NewQLabel2(struct QtWidgets_PackedString text, void* parent, long long fo)
void* QLabel_NewQLabel2(struct QtWidgets_PackedString text, void* parent, long long ff)
{
return new MyQLabel(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
return new MyQLabel(QString::fromUtf8(text.data, text.len), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}
void QLabel_Clear(void* ptr)
@ -38977,7 +38977,7 @@ void QMenuBar_InitStyleOption(void* ptr, void* option, void* action)
class MyQMessageBox: public QMessageBox
{
public:
MyQMessageBox(QMessageBox::Icon icon, const QString &title, const QString &text, QMessageBox::StandardButtons buttons, QWidget *parent = Q_NULLPTR, Qt::WindowFlags fo = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint) : QMessageBox(icon, title, text, buttons, parent, fo) {QMessageBox_QMessageBox_QRegisterMetaType();};
MyQMessageBox(QMessageBox::Icon icon, const QString &title, const QString &text, QMessageBox::StandardButtons buttons, QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint) : QMessageBox(icon, title, text, buttons, parent, ff) {QMessageBox_QMessageBox_QRegisterMetaType();};
MyQMessageBox(QWidget *parent = Q_NULLPTR) : QMessageBox(parent) {QMessageBox_QMessageBox_QRegisterMetaType();};
bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
int exec() { return callbackQDialog_Exec(this); };
@ -39067,9 +39067,9 @@ int QMessageBox_ButtonMask_Type()
return QMessageBox::ButtonMask;
}
void* QMessageBox_NewQMessageBox2(long long icon, struct QtWidgets_PackedString title, struct QtWidgets_PackedString text, long long buttons, void* parent, long long fo)
void* QMessageBox_NewQMessageBox2(long long icon, struct QtWidgets_PackedString title, struct QtWidgets_PackedString text, long long buttons, void* parent, long long ff)
{
return new MyQMessageBox(static_cast<QMessageBox::Icon>(icon), QString::fromUtf8(title.data, title.len), QString::fromUtf8(text.data, text.len), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
return new MyQMessageBox(static_cast<QMessageBox::Icon>(icon), QString::fromUtf8(title.data, title.len), QString::fromUtf8(text.data, text.len), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}
void* QMessageBox_NewQMessageBox(void* parent)
@ -39713,7 +39713,7 @@ void QMouseEventTransition_TimerEventDefault(void* ptr, void* event)
class MyQOpenGLWidget: public QOpenGLWidget
{
public:
MyQOpenGLWidget(QWidget *parent = Q_NULLPTR, Qt::WindowFlags fo = Qt::WindowFlags()) : QOpenGLWidget(parent, fo) {QOpenGLWidget_QOpenGLWidget_QRegisterMetaType();};
MyQOpenGLWidget(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QOpenGLWidget(parent, ff) {QOpenGLWidget_QOpenGLWidget_QRegisterMetaType();};
void Signal_AboutToCompose() { callbackQOpenGLWidget_AboutToCompose(this); };
void Signal_AboutToResize() { callbackQOpenGLWidget_AboutToResize(this); };
void Signal_FrameSwapped() { callbackQOpenGLWidget_FrameSwapped(this); };
@ -39802,9 +39802,9 @@ void* QOpenGLWidget_GrabFramebuffer(void* ptr)
return new QImage(static_cast<QOpenGLWidget*>(ptr)->grabFramebuffer());
}
void* QOpenGLWidget_NewQOpenGLWidget(void* parent, long long fo)
void* QOpenGLWidget_NewQOpenGLWidget(void* parent, long long ff)
{
return new MyQOpenGLWidget(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
return new MyQOpenGLWidget(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}
void QOpenGLWidget_ConnectAboutToCompose(void* ptr)
@ -41514,8 +41514,8 @@ void QProgressBar_InitStyleOption(void* ptr, void* option)
class MyQProgressDialog: public QProgressDialog
{
public:
MyQProgressDialog(QWidget *parent = Q_NULLPTR, Qt::WindowFlags fo = Qt::WindowFlags()) : QProgressDialog(parent, fo) {QProgressDialog_QProgressDialog_QRegisterMetaType();};
MyQProgressDialog(const QString &labelText, const QString &cancelButtonText, int minimum, int maximum, QWidget *parent = Q_NULLPTR, Qt::WindowFlags fo = Qt::WindowFlags()) : QProgressDialog(labelText, cancelButtonText, minimum, maximum, parent, fo) {QProgressDialog_QProgressDialog_QRegisterMetaType();};
MyQProgressDialog(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QProgressDialog(parent, ff) {QProgressDialog_QProgressDialog_QRegisterMetaType();};
MyQProgressDialog(const QString &labelText, const QString &cancelButtonText, int minimum, int maximum, QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QProgressDialog(labelText, cancelButtonText, minimum, maximum, parent, ff) {QProgressDialog_QProgressDialog_QRegisterMetaType();};
void cancel() { callbackQProgressDialog_Cancel(this); };
void Signal_Canceled() { callbackQProgressDialog_Canceled(this); };
void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
@ -41610,14 +41610,14 @@ Q_DECLARE_METATYPE(MyQProgressDialog*)
int QProgressDialog_QProgressDialog_QRegisterMetaType(){qRegisterMetaType<QProgressDialog*>(); return qRegisterMetaType<MyQProgressDialog*>();}
void* QProgressDialog_NewQProgressDialog(void* parent, long long fo)
void* QProgressDialog_NewQProgressDialog(void* parent, long long ff)
{
return new MyQProgressDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
return new MyQProgressDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}
void* QProgressDialog_NewQProgressDialog2(struct QtWidgets_PackedString labelText, struct QtWidgets_PackedString cancelButtonText, int minimum, int maximum, void* parent, long long fo)
void* QProgressDialog_NewQProgressDialog2(struct QtWidgets_PackedString labelText, struct QtWidgets_PackedString cancelButtonText, int minimum, int maximum, void* parent, long long ff)
{
return new MyQProgressDialog(QString::fromUtf8(labelText.data, labelText.len), QString::fromUtf8(cancelButtonText.data, cancelButtonText.len), minimum, maximum, static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
return new MyQProgressDialog(QString::fromUtf8(labelText.data, labelText.len), QString::fromUtf8(cancelButtonText.data, cancelButtonText.len), minimum, maximum, static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}
void QProgressDialog_Cancel(void* ptr)
@ -44195,8 +44195,8 @@ int QSpinBox_ValueFromTextDefault(void* ptr, struct QtWidgets_PackedString text)
class MyQSplashScreen: public QSplashScreen
{
public:
MyQSplashScreen(QWidget *parent, const QPixmap &pixmap = QPixmap(), Qt::WindowFlags fo = Qt::WindowFlags()) : QSplashScreen(parent, pixmap, fo) {QSplashScreen_QSplashScreen_QRegisterMetaType();};
MyQSplashScreen(const QPixmap &pixmap = QPixmap(), Qt::WindowFlags fo = Qt::WindowFlags()) : QSplashScreen(pixmap, fo) {QSplashScreen_QSplashScreen_QRegisterMetaType();};
MyQSplashScreen(QWidget *parent, const QPixmap &pixmap = QPixmap(), Qt::WindowFlags ff = Qt::WindowFlags()) : QSplashScreen(parent, pixmap, ff) {QSplashScreen_QSplashScreen_QRegisterMetaType();};
MyQSplashScreen(const QPixmap &pixmap = QPixmap(), Qt::WindowFlags ff = Qt::WindowFlags()) : QSplashScreen(pixmap, ff) {QSplashScreen_QSplashScreen_QRegisterMetaType();};
bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
void clearMessage() { callbackQSplashScreen_ClearMessage(this); };
void drawContents(QPainter * painter) { callbackQSplashScreen_DrawContents(this, painter); };
@ -44276,14 +44276,14 @@ Q_DECLARE_METATYPE(MyQSplashScreen*)
int QSplashScreen_QSplashScreen_QRegisterMetaType(){qRegisterMetaType<QSplashScreen*>(); return qRegisterMetaType<MyQSplashScreen*>();}
void* QSplashScreen_NewQSplashScreen2(void* parent, void* pixmap, long long fo)
void* QSplashScreen_NewQSplashScreen2(void* parent, void* pixmap, long long ff)
{
return new MyQSplashScreen(static_cast<QWidget*>(parent), *static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(fo));
return new MyQSplashScreen(static_cast<QWidget*>(parent), *static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(ff));
}
void* QSplashScreen_NewQSplashScreen(void* pixmap, long long fo)
void* QSplashScreen_NewQSplashScreen(void* pixmap, long long ff)
{
return new MyQSplashScreen(*static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(fo));
return new MyQSplashScreen(*static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(ff));
}
void QSplashScreen_ClearMessage(void* ptr)
@ -51710,7 +51710,7 @@ public:
void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
void copy() { callbackQTextEdit_Copy(this); };
void Signal_CopyAvailable(bool yes) { callbackQTextEdit_CopyAvailable(this, yes); };
void Signal_CurrentCharFormatChanged(const QTextCharFormat & fo) { callbackQTextEdit_CurrentCharFormatChanged(this, const_cast<QTextCharFormat*>(&fo)); };
void Signal_CurrentCharFormatChanged(const QTextCharFormat & ff) { callbackQTextEdit_CurrentCharFormatChanged(this, const_cast<QTextCharFormat*>(&ff)); };
void Signal_CursorPositionChanged() { callbackQTextEdit_CursorPositionChanged(this); };
void cut() { callbackQTextEdit_Cut(this); };
void dragEnterEvent(QDragEnterEvent * e) { callbackQWidget_DragEnterEvent(this, e); };
@ -51733,7 +51733,7 @@ public:
void selectAll() { callbackQTextEdit_SelectAll(this); };
void Signal_SelectionChanged() { callbackQTextEdit_SelectionChanged(this); };
void setAlignment(Qt::Alignment a) { callbackQTextEdit_SetAlignment(this, a); };
void setCurrentFont(const QFont & fo) { callbackQTextEdit_SetCurrentFont(this, const_cast<QFont*>(&fo)); };
void setCurrentFont(const QFont & ff) { callbackQTextEdit_SetCurrentFont(this, const_cast<QFont*>(&ff)); };
void setFontFamily(const QString & fontFamily) { QByteArray t5db177 = fontFamily.toUtf8(); QtWidgets_PackedString fontFamilyPacked = { const_cast<char*>(t5db177.prepend("WHITESPACE").constData()+10), t5db177.size()-10 };callbackQTextEdit_SetFontFamily(this, fontFamilyPacked); };
void setFontItalic(bool italic) { callbackQTextEdit_SetFontItalic(this, italic); };
void setFontPointSize(qreal s) { callbackQTextEdit_SetFontPointSize(this, s); };
@ -52072,7 +52072,7 @@ public:
void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
void copy() { callbackQTextEdit_Copy(this); };
void Signal_CopyAvailable(bool yes) { callbackQTextEdit_CopyAvailable(this, yes); };
void Signal_CurrentCharFormatChanged(const QTextCharFormat & fo) { callbackQTextEdit_CurrentCharFormatChanged(this, const_cast<QTextCharFormat*>(&fo)); };
void Signal_CurrentCharFormatChanged(const QTextCharFormat & ff) { callbackQTextEdit_CurrentCharFormatChanged(this, const_cast<QTextCharFormat*>(&ff)); };
void Signal_CursorPositionChanged() { callbackQTextEdit_CursorPositionChanged(this); };
void cut() { callbackQTextEdit_Cut(this); };
void dragEnterEvent(QDragEnterEvent * e) { callbackQWidget_DragEnterEvent(this, e); };
@ -52101,7 +52101,7 @@ public:
void selectAll() { callbackQTextEdit_SelectAll(this); };
void Signal_SelectionChanged() { callbackQTextEdit_SelectionChanged(this); };
void setAlignment(Qt::Alignment a) { callbackQTextEdit_SetAlignment(this, a); };
void setCurrentFont(const QFont & fo) { callbackQTextEdit_SetCurrentFont(this, const_cast<QFont*>(&fo)); };
void setCurrentFont(const QFont & ff) { callbackQTextEdit_SetCurrentFont(this, const_cast<QFont*>(&ff)); };
void setFontFamily(const QString & fontFamily) { QByteArray t5db177 = fontFamily.toUtf8(); QtWidgets_PackedString fontFamilyPacked = { const_cast<char*>(t5db177.prepend("WHITESPACE").constData()+10), t5db177.size()-10 };callbackQTextEdit_SetFontFamily(this, fontFamilyPacked); };
void setFontItalic(bool italic) { callbackQTextEdit_SetFontItalic(this, italic); };
void setFontPointSize(qreal s) { callbackQTextEdit_SetFontPointSize(this, s); };
@ -52291,9 +52291,9 @@ void QTextEdit_DisconnectCurrentCharFormatChanged(void* ptr)
QObject::disconnect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)(const QTextCharFormat &)>(&QTextEdit::currentCharFormatChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)(const QTextCharFormat &)>(&MyQTextEdit::Signal_CurrentCharFormatChanged));
}
void QTextEdit_CurrentCharFormatChanged(void* ptr, void* fo)
void QTextEdit_CurrentCharFormatChanged(void* ptr, void* ff)
{
static_cast<QTextEdit*>(ptr)->currentCharFormatChanged(*static_cast<QTextCharFormat*>(fo));
static_cast<QTextEdit*>(ptr)->currentCharFormatChanged(*static_cast<QTextCharFormat*>(ff));
}
void QTextEdit_ConnectCursorPositionChanged(void* ptr)
@ -52498,17 +52498,17 @@ void QTextEdit_SetCurrentCharFormat(void* ptr, void* format)
static_cast<QTextEdit*>(ptr)->setCurrentCharFormat(*static_cast<QTextCharFormat*>(format));
}
void QTextEdit_SetCurrentFont(void* ptr, void* fo)
void QTextEdit_SetCurrentFont(void* ptr, void* ff)
{
QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setCurrentFont", Q_ARG(const QFont, *static_cast<QFont*>(fo)));
QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setCurrentFont", Q_ARG(const QFont, *static_cast<QFont*>(ff)));
}
void QTextEdit_SetCurrentFontDefault(void* ptr, void* fo)
void QTextEdit_SetCurrentFontDefault(void* ptr, void* ff)
{
if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
static_cast<QTextBrowser*>(ptr)->QTextBrowser::setCurrentFont(*static_cast<QFont*>(fo));
static_cast<QTextBrowser*>(ptr)->QTextBrowser::setCurrentFont(*static_cast<QFont*>(ff));
} else {
static_cast<QTextEdit*>(ptr)->QTextEdit::setCurrentFont(*static_cast<QFont*>(fo));
static_cast<QTextEdit*>(ptr)->QTextEdit::setCurrentFont(*static_cast<QFont*>(ff));
}
}
@ -53049,7 +53049,7 @@ class MyQTimeEdit: public QTimeEdit
{
public:
MyQTimeEdit(QWidget *parent = Q_NULLPTR) : QTimeEdit(parent) {QTimeEdit_QTimeEdit_QRegisterMetaType();};
MyQTimeEdit(const QTime &time, QWidget *parent = Q_NULLPTR) : QTimeEdit(time, parent) {QTimeEdit_QTimeEdit_QRegisterMetaType();};
MyQTimeEdit(const QTime &ti, QWidget *parent = Q_NULLPTR) : QTimeEdit(ti, parent) {QTimeEdit_QTimeEdit_QRegisterMetaType();};
~MyQTimeEdit() { callbackQTimeEdit_DestroyQTimeEdit(this); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
@ -53063,9 +53063,9 @@ public:
void paintEvent(QPaintEvent * event) { callbackQWidget_PaintEvent(this, event); };
void setDate(const QDate & date) { callbackQDateTimeEdit_SetDate(this, const_cast<QDate*>(&date)); };
void setDateTime(const QDateTime & dateTime) { callbackQDateTimeEdit_SetDateTime(this, const_cast<QDateTime*>(&dateTime)); };
void setTime(const QTime & time) { callbackQDateTimeEdit_SetTime(this, const_cast<QTime*>(&time)); };
void setTime(const QTime & ti) { callbackQDateTimeEdit_SetTime(this, const_cast<QTime*>(&ti)); };
void stepBy(int steps) { callbackQAbstractSpinBox_StepBy(this, steps); };
void Signal_TimeChanged(const QTime & time) { callbackQDateTimeEdit_TimeChanged(this, const_cast<QTime*>(&time)); };
void Signal_TimeChanged(const QTime & ti) { callbackQDateTimeEdit_TimeChanged(this, const_cast<QTime*>(&ti)); };
void wheelEvent(QWheelEvent * event) { callbackQWidget_WheelEvent(this, event); };
QAbstractSpinBox::StepEnabled stepEnabled() const { return static_cast<QAbstractSpinBox::StepEnabledFlag>(callbackQAbstractSpinBox_StepEnabled(const_cast<void*>(static_cast<const void*>(this)))); };
QDateTime dateTimeFromText(const QString & text) const { QByteArray t372ea0 = text.toUtf8(); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };return *static_cast<QDateTime*>(callbackQDateTimeEdit_DateTimeFromText(const_cast<void*>(static_cast<const void*>(this)), textPacked)); };
@ -53148,9 +53148,9 @@ void* QTimeEdit_NewQTimeEdit(void* parent)
return new MyQTimeEdit(static_cast<QWidget*>(parent));
}
void* QTimeEdit_NewQTimeEdit2(void* time, void* parent)
void* QTimeEdit_NewQTimeEdit2(void* ti, void* parent)
{
return new MyQTimeEdit(*static_cast<QTime*>(time), static_cast<QWidget*>(parent));
return new MyQTimeEdit(*static_cast<QTime*>(ti), static_cast<QWidget*>(parent));
}
void QTimeEdit_DestroyQTimeEdit(void* ptr)
@ -53568,7 +53568,7 @@ char QToolBar_IsMovable(void* ptr)
class MyQToolBox: public QToolBox
{
public:
MyQToolBox(QWidget *parent = Q_NULLPTR, Qt::WindowFlags fo = Qt::WindowFlags()) : QToolBox(parent, fo) {QToolBox_QToolBox_QRegisterMetaType();};
MyQToolBox(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QToolBox(parent, ff) {QToolBox_QToolBox_QRegisterMetaType();};
bool event(QEvent * e) { return callbackQWidget_Event(this, e) != 0; };
void changeEvent(QEvent * ev) { callbackQWidget_ChangeEvent(this, ev); };
void Signal_CurrentChanged(int index) { callbackQToolBox_CurrentChanged(this, index); };
@ -53650,9 +53650,9 @@ Q_DECLARE_METATYPE(MyQToolBox*)
int QToolBox_QToolBox_QRegisterMetaType(){qRegisterMetaType<QToolBox*>(); return qRegisterMetaType<MyQToolBox*>();}
void* QToolBox_NewQToolBox(void* parent, long long fo)
void* QToolBox_NewQToolBox(void* parent, long long ff)
{
return new MyQToolBox(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
return new MyQToolBox(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}
int QToolBox_AddItem2(void* ptr, void* w, struct QtWidgets_PackedString text)
@ -57565,7 +57565,7 @@ void QWhatsThis_QWhatsThis_ShowText(void* pos, struct QtWidgets_PackedString tex
class MyQWidget: public QWidget
{
public:
MyQWidget(QWidget *parent = Q_NULLPTR, Qt::WindowFlags fo = Qt::WindowFlags()) : QWidget(parent, fo) {QWidget_QWidget_QRegisterMetaType();};
MyQWidget(QWidget *parent = Q_NULLPTR, Qt::WindowFlags ff = Qt::WindowFlags()) : QWidget(parent, ff) {QWidget_QWidget_QRegisterMetaType();};
bool close() { return callbackQWidget_Close(this) != 0; };
bool event(QEvent * event) { return callbackQWidget_Event(this, event) != 0; };
bool focusNextPrevChild(bool next) { return callbackQWidget_FocusNextPrevChild(this, next) != 0; };
@ -57677,9 +57677,9 @@ void* QWidget_QWidget_MouseGrabber()
return QWidget::mouseGrabber();
}
void* QWidget_NewQWidget(void* parent, long long fo)
void* QWidget_NewQWidget(void* parent, long long ff)
{
return new MyQWidget(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
return new MyQWidget(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}
char QWidget_Close(void* ptr)
@ -64067,9 +64067,9 @@ void QWidget_SetParent(void* ptr, void* parent)
static_cast<QWidget*>(ptr)->setParent(static_cast<QWidget*>(parent));
}
void QWidget_SetParent2(void* ptr, void* parent, long long fo)
void QWidget_SetParent2(void* ptr, void* parent, long long ff)
{
static_cast<QWidget*>(ptr)->setParent(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
static_cast<QWidget*>(ptr)->setParent(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(ff));
}
void QWidget_SetShortcutAutoRepeat(void* ptr, int id, char enable)

158
widgets/widgets.go
View file

@ -18914,8 +18914,8 @@ func NewQDateTimeEdit2(datetime core.QDateTime_ITF, parent QWidget_ITF) *QDateTi
return tmpValue
}
func NewQDateTimeEdit4(time core.QTime_ITF, parent QWidget_ITF) *QDateTimeEdit {
tmpValue := NewQDateTimeEditFromPointer(C.QDateTimeEdit_NewQDateTimeEdit4(core.PointerFromQTime(time), PointerFromQWidget(parent)))
func NewQDateTimeEdit4(ti core.QTime_ITF, parent QWidget_ITF) *QDateTimeEdit {
tmpValue := NewQDateTimeEditFromPointer(C.QDateTimeEdit_NewQDateTimeEdit4(core.PointerFromQTime(ti), PointerFromQWidget(parent)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
@ -19252,21 +19252,21 @@ func (ptr *QDateTimeEdit) SetSelectedSection(section QDateTimeEdit__Section) {
}
//export callbackQDateTimeEdit_SetTime
func callbackQDateTimeEdit_SetTime(ptr unsafe.Pointer, time unsafe.Pointer) {
func callbackQDateTimeEdit_SetTime(ptr unsafe.Pointer, ti unsafe.Pointer) {
if signal := qt.GetSignal(ptr, "setTime"); signal != nil {
signal.(func(*core.QTime))(core.NewQTimeFromPointer(time))
signal.(func(*core.QTime))(core.NewQTimeFromPointer(ti))
} else {
NewQDateTimeEditFromPointer(ptr).SetTimeDefault(core.NewQTimeFromPointer(time))
NewQDateTimeEditFromPointer(ptr).SetTimeDefault(core.NewQTimeFromPointer(ti))
}
}
func (ptr *QDateTimeEdit) ConnectSetTime(f func(time *core.QTime)) {
func (ptr *QDateTimeEdit) ConnectSetTime(f func(ti *core.QTime)) {
if ptr.Pointer() != nil {
if signal := qt.LendSignal(ptr.Pointer(), "setTime"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "setTime", func(time *core.QTime) {
signal.(func(*core.QTime))(time)
f(time)
qt.ConnectSignal(ptr.Pointer(), "setTime", func(ti *core.QTime) {
signal.(func(*core.QTime))(ti)
f(ti)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "setTime", f)
@ -19281,15 +19281,15 @@ func (ptr *QDateTimeEdit) DisconnectSetTime() {
}
}
func (ptr *QDateTimeEdit) SetTime(time core.QTime_ITF) {
func (ptr *QDateTimeEdit) SetTime(ti core.QTime_ITF) {
if ptr.Pointer() != nil {
C.QDateTimeEdit_SetTime(ptr.Pointer(), core.PointerFromQTime(time))
C.QDateTimeEdit_SetTime(ptr.Pointer(), core.PointerFromQTime(ti))
}
}
func (ptr *QDateTimeEdit) SetTimeDefault(time core.QTime_ITF) {
func (ptr *QDateTimeEdit) SetTimeDefault(ti core.QTime_ITF) {
if ptr.Pointer() != nil {
C.QDateTimeEdit_SetTimeDefault(ptr.Pointer(), core.PointerFromQTime(time))
C.QDateTimeEdit_SetTimeDefault(ptr.Pointer(), core.PointerFromQTime(ti))
}
}
@ -19306,14 +19306,14 @@ func (ptr *QDateTimeEdit) SetTimeSpec(spec core.Qt__TimeSpec) {
}
//export callbackQDateTimeEdit_TimeChanged
func callbackQDateTimeEdit_TimeChanged(ptr unsafe.Pointer, time unsafe.Pointer) {
func callbackQDateTimeEdit_TimeChanged(ptr unsafe.Pointer, ti unsafe.Pointer) {
if signal := qt.GetSignal(ptr, "timeChanged"); signal != nil {
signal.(func(*core.QTime))(core.NewQTimeFromPointer(time))
signal.(func(*core.QTime))(core.NewQTimeFromPointer(ti))
}
}
func (ptr *QDateTimeEdit) ConnectTimeChanged(f func(time *core.QTime)) {
func (ptr *QDateTimeEdit) ConnectTimeChanged(f func(ti *core.QTime)) {
if ptr.Pointer() != nil {
if !qt.ExistsSignal(ptr.Pointer(), "timeChanged") {
@ -19321,9 +19321,9 @@ func (ptr *QDateTimeEdit) ConnectTimeChanged(f func(time *core.QTime)) {
}
if signal := qt.LendSignal(ptr.Pointer(), "timeChanged"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "timeChanged", func(time *core.QTime) {
signal.(func(*core.QTime))(time)
f(time)
qt.ConnectSignal(ptr.Pointer(), "timeChanged", func(ti *core.QTime) {
signal.(func(*core.QTime))(ti)
f(ti)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "timeChanged", f)
@ -19338,9 +19338,9 @@ func (ptr *QDateTimeEdit) DisconnectTimeChanged() {
}
}
func (ptr *QDateTimeEdit) TimeChanged(time core.QTime_ITF) {
func (ptr *QDateTimeEdit) TimeChanged(ti core.QTime_ITF) {
if ptr.Pointer() != nil {
C.QDateTimeEdit_TimeChanged(ptr.Pointer(), core.PointerFromQTime(time))
C.QDateTimeEdit_TimeChanged(ptr.Pointer(), core.PointerFromQTime(ti))
}
}
@ -20195,8 +20195,8 @@ const (
QDialog__Accepted QDialog__DialogCode = QDialog__DialogCode(1)
)
func NewQDialog(parent QWidget_ITF, fo core.Qt__WindowType) *QDialog {
tmpValue := NewQDialogFromPointer(C.QDialog_NewQDialog(PointerFromQWidget(parent), C.longlong(fo)))
func NewQDialog(parent QWidget_ITF, ff core.Qt__WindowType) *QDialog {
tmpValue := NewQDialogFromPointer(C.QDialog_NewQDialog(PointerFromQWidget(parent), C.longlong(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
@ -28303,21 +28303,21 @@ func (ptr *QFontComboBox) CurrentFontChanged(font gui.QFont_ITF) {
}
//export callbackQFontComboBox_SetCurrentFont
func callbackQFontComboBox_SetCurrentFont(ptr unsafe.Pointer, fo unsafe.Pointer) {
func callbackQFontComboBox_SetCurrentFont(ptr unsafe.Pointer, ff unsafe.Pointer) {
if signal := qt.GetSignal(ptr, "setCurrentFont"); signal != nil {
signal.(func(*gui.QFont))(gui.NewQFontFromPointer(fo))
signal.(func(*gui.QFont))(gui.NewQFontFromPointer(ff))
} else {
NewQFontComboBoxFromPointer(ptr).SetCurrentFontDefault(gui.NewQFontFromPointer(fo))
NewQFontComboBoxFromPointer(ptr).SetCurrentFontDefault(gui.NewQFontFromPointer(ff))
}
}
func (ptr *QFontComboBox) ConnectSetCurrentFont(f func(fo *gui.QFont)) {
func (ptr *QFontComboBox) ConnectSetCurrentFont(f func(ff *gui.QFont)) {
if ptr.Pointer() != nil {
if signal := qt.LendSignal(ptr.Pointer(), "setCurrentFont"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "setCurrentFont", func(fo *gui.QFont) {
signal.(func(*gui.QFont))(fo)
f(fo)
qt.ConnectSignal(ptr.Pointer(), "setCurrentFont", func(ff *gui.QFont) {
signal.(func(*gui.QFont))(ff)
f(ff)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "setCurrentFont", f)
@ -28332,15 +28332,15 @@ func (ptr *QFontComboBox) DisconnectSetCurrentFont() {
}
}
func (ptr *QFontComboBox) SetCurrentFont(fo gui.QFont_ITF) {
func (ptr *QFontComboBox) SetCurrentFont(ff gui.QFont_ITF) {
if ptr.Pointer() != nil {
C.QFontComboBox_SetCurrentFont(ptr.Pointer(), gui.PointerFromQFont(fo))
C.QFontComboBox_SetCurrentFont(ptr.Pointer(), gui.PointerFromQFont(ff))
}
}
func (ptr *QFontComboBox) SetCurrentFontDefault(fo gui.QFont_ITF) {
func (ptr *QFontComboBox) SetCurrentFontDefault(ff gui.QFont_ITF) {
if ptr.Pointer() != nil {
C.QFontComboBox_SetCurrentFontDefault(ptr.Pointer(), gui.PointerFromQFont(fo))
C.QFontComboBox_SetCurrentFontDefault(ptr.Pointer(), gui.PointerFromQFont(ff))
}
}
@ -29317,8 +29317,8 @@ var (
QFrame__Shape_Mask QFrame__StyleMask = QFrame__StyleMask(0x000f)
)
func NewQFrame(parent QWidget_ITF, fo core.Qt__WindowType) *QFrame {
tmpValue := NewQFrameFromPointer(C.QFrame_NewQFrame(PointerFromQWidget(parent), C.longlong(fo)))
func NewQFrame(parent QWidget_ITF, ff core.Qt__WindowType) *QFrame {
tmpValue := NewQFrameFromPointer(C.QFrame_NewQFrame(PointerFromQWidget(parent), C.longlong(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
@ -55917,21 +55917,21 @@ func NewQLabelFromPointer(ptr unsafe.Pointer) (n *QLabel) {
n.SetPointer(ptr)
return
}
func NewQLabel(parent QWidget_ITF, fo core.Qt__WindowType) *QLabel {
tmpValue := NewQLabelFromPointer(C.QLabel_NewQLabel(PointerFromQWidget(parent), C.longlong(fo)))
func NewQLabel(parent QWidget_ITF, ff core.Qt__WindowType) *QLabel {
tmpValue := NewQLabelFromPointer(C.QLabel_NewQLabel(PointerFromQWidget(parent), C.longlong(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
return tmpValue
}
func NewQLabel2(text string, parent QWidget_ITF, fo core.Qt__WindowType) *QLabel {
func NewQLabel2(text string, parent QWidget_ITF, ff core.Qt__WindowType) *QLabel {
var textC *C.char
if text != "" {
textC = C.CString(text)
defer C.free(unsafe.Pointer(textC))
}
tmpValue := NewQLabelFromPointer(C.QLabel_NewQLabel2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(parent), C.longlong(fo)))
tmpValue := NewQLabelFromPointer(C.QLabel_NewQLabel2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(parent), C.longlong(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
@ -65620,7 +65620,7 @@ var (
QMessageBox__ButtonMask QMessageBox__StandardButton = QMessageBox__StandardButton(C.QMessageBox_ButtonMask_Type())
)
func NewQMessageBox2(icon QMessageBox__Icon, title string, text string, buttons QMessageBox__StandardButton, parent QWidget_ITF, fo core.Qt__WindowType) *QMessageBox {
func NewQMessageBox2(icon QMessageBox__Icon, title string, text string, buttons QMessageBox__StandardButton, parent QWidget_ITF, ff core.Qt__WindowType) *QMessageBox {
var titleC *C.char
if title != "" {
titleC = C.CString(title)
@ -65631,7 +65631,7 @@ func NewQMessageBox2(icon QMessageBox__Icon, title string, text string, buttons
textC = C.CString(text)
defer C.free(unsafe.Pointer(textC))
}
tmpValue := NewQMessageBoxFromPointer(C.QMessageBox_NewQMessageBox2(C.longlong(icon), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(buttons), PointerFromQWidget(parent), C.longlong(fo)))
tmpValue := NewQMessageBoxFromPointer(C.QMessageBox_NewQMessageBox2(C.longlong(icon), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(buttons), PointerFromQWidget(parent), C.longlong(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
@ -66948,8 +66948,8 @@ func (ptr *QOpenGLWidget) GrabFramebuffer() *gui.QImage {
return nil
}
func NewQOpenGLWidget(parent QWidget_ITF, fo core.Qt__WindowType) *QOpenGLWidget {
tmpValue := NewQOpenGLWidgetFromPointer(C.QOpenGLWidget_NewQOpenGLWidget(PointerFromQWidget(parent), C.longlong(fo)))
func NewQOpenGLWidget(parent QWidget_ITF, ff core.Qt__WindowType) *QOpenGLWidget {
tmpValue := NewQOpenGLWidgetFromPointer(C.QOpenGLWidget_NewQOpenGLWidget(PointerFromQWidget(parent), C.longlong(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
@ -70850,15 +70850,15 @@ func NewQProgressDialogFromPointer(ptr unsafe.Pointer) (n *QProgressDialog) {
n.SetPointer(ptr)
return
}
func NewQProgressDialog(parent QWidget_ITF, fo core.Qt__WindowType) *QProgressDialog {
tmpValue := NewQProgressDialogFromPointer(C.QProgressDialog_NewQProgressDialog(PointerFromQWidget(parent), C.longlong(fo)))
func NewQProgressDialog(parent QWidget_ITF, ff core.Qt__WindowType) *QProgressDialog {
tmpValue := NewQProgressDialogFromPointer(C.QProgressDialog_NewQProgressDialog(PointerFromQWidget(parent), C.longlong(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
return tmpValue
}
func NewQProgressDialog2(labelText string, cancelButtonText string, minimum int, maximum int, parent QWidget_ITF, fo core.Qt__WindowType) *QProgressDialog {
func NewQProgressDialog2(labelText string, cancelButtonText string, minimum int, maximum int, parent QWidget_ITF, ff core.Qt__WindowType) *QProgressDialog {
var labelTextC *C.char
if labelText != "" {
labelTextC = C.CString(labelText)
@ -70869,7 +70869,7 @@ func NewQProgressDialog2(labelText string, cancelButtonText string, minimum int,
cancelButtonTextC = C.CString(cancelButtonText)
defer C.free(unsafe.Pointer(cancelButtonTextC))
}
tmpValue := NewQProgressDialogFromPointer(C.QProgressDialog_NewQProgressDialog2(C.struct_QtWidgets_PackedString{data: labelTextC, len: C.longlong(len(labelText))}, C.struct_QtWidgets_PackedString{data: cancelButtonTextC, len: C.longlong(len(cancelButtonText))}, C.int(int32(minimum)), C.int(int32(maximum)), PointerFromQWidget(parent), C.longlong(fo)))
tmpValue := NewQProgressDialogFromPointer(C.QProgressDialog_NewQProgressDialog2(C.struct_QtWidgets_PackedString{data: labelTextC, len: C.longlong(len(labelText))}, C.struct_QtWidgets_PackedString{data: cancelButtonTextC, len: C.longlong(len(cancelButtonText))}, C.int(int32(minimum)), C.int(int32(maximum)), PointerFromQWidget(parent), C.longlong(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
@ -75587,16 +75587,16 @@ func NewQSplashScreenFromPointer(ptr unsafe.Pointer) (n *QSplashScreen) {
n.SetPointer(ptr)
return
}
func NewQSplashScreen2(parent QWidget_ITF, pixmap gui.QPixmap_ITF, fo core.Qt__WindowType) *QSplashScreen {
tmpValue := NewQSplashScreenFromPointer(C.QSplashScreen_NewQSplashScreen2(PointerFromQWidget(parent), gui.PointerFromQPixmap(pixmap), C.longlong(fo)))
func NewQSplashScreen2(parent QWidget_ITF, pixmap gui.QPixmap_ITF, ff core.Qt__WindowType) *QSplashScreen {
tmpValue := NewQSplashScreenFromPointer(C.QSplashScreen_NewQSplashScreen2(PointerFromQWidget(parent), gui.PointerFromQPixmap(pixmap), C.longlong(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
return tmpValue
}
func NewQSplashScreen(pixmap gui.QPixmap_ITF, fo core.Qt__WindowType) *QSplashScreen {
tmpValue := NewQSplashScreenFromPointer(C.QSplashScreen_NewQSplashScreen(gui.PointerFromQPixmap(pixmap), C.longlong(fo)))
func NewQSplashScreen(pixmap gui.QPixmap_ITF, ff core.Qt__WindowType) *QSplashScreen {
tmpValue := NewQSplashScreenFromPointer(C.QSplashScreen_NewQSplashScreen(gui.PointerFromQPixmap(pixmap), C.longlong(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
@ -92953,14 +92953,14 @@ func (ptr *QTextEdit) CopyAvailable(yes bool) {
}
//export callbackQTextEdit_CurrentCharFormatChanged
func callbackQTextEdit_CurrentCharFormatChanged(ptr unsafe.Pointer, fo unsafe.Pointer) {
func callbackQTextEdit_CurrentCharFormatChanged(ptr unsafe.Pointer, ff unsafe.Pointer) {
if signal := qt.GetSignal(ptr, "currentCharFormatChanged"); signal != nil {
signal.(func(*gui.QTextCharFormat))(gui.NewQTextCharFormatFromPointer(fo))
signal.(func(*gui.QTextCharFormat))(gui.NewQTextCharFormatFromPointer(ff))
}
}
func (ptr *QTextEdit) ConnectCurrentCharFormatChanged(f func(fo *gui.QTextCharFormat)) {
func (ptr *QTextEdit) ConnectCurrentCharFormatChanged(f func(ff *gui.QTextCharFormat)) {
if ptr.Pointer() != nil {
if !qt.ExistsSignal(ptr.Pointer(), "currentCharFormatChanged") {
@ -92968,9 +92968,9 @@ func (ptr *QTextEdit) ConnectCurrentCharFormatChanged(f func(fo *gui.QTextCharFo
}
if signal := qt.LendSignal(ptr.Pointer(), "currentCharFormatChanged"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "currentCharFormatChanged", func(fo *gui.QTextCharFormat) {
signal.(func(*gui.QTextCharFormat))(fo)
f(fo)
qt.ConnectSignal(ptr.Pointer(), "currentCharFormatChanged", func(ff *gui.QTextCharFormat) {
signal.(func(*gui.QTextCharFormat))(ff)
f(ff)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "currentCharFormatChanged", f)
@ -92985,9 +92985,9 @@ func (ptr *QTextEdit) DisconnectCurrentCharFormatChanged() {
}
}
func (ptr *QTextEdit) CurrentCharFormatChanged(fo gui.QTextCharFormat_ITF) {
func (ptr *QTextEdit) CurrentCharFormatChanged(ff gui.QTextCharFormat_ITF) {
if ptr.Pointer() != nil {
C.QTextEdit_CurrentCharFormatChanged(ptr.Pointer(), gui.PointerFromQTextCharFormat(fo))
C.QTextEdit_CurrentCharFormatChanged(ptr.Pointer(), gui.PointerFromQTextCharFormat(ff))
}
}
@ -93553,21 +93553,21 @@ func (ptr *QTextEdit) SetCurrentCharFormat(format gui.QTextCharFormat_ITF) {
}
//export callbackQTextEdit_SetCurrentFont
func callbackQTextEdit_SetCurrentFont(ptr unsafe.Pointer, fo unsafe.Pointer) {
func callbackQTextEdit_SetCurrentFont(ptr unsafe.Pointer, ff unsafe.Pointer) {
if signal := qt.GetSignal(ptr, "setCurrentFont"); signal != nil {
signal.(func(*gui.QFont))(gui.NewQFontFromPointer(fo))
signal.(func(*gui.QFont))(gui.NewQFontFromPointer(ff))
} else {
NewQTextEditFromPointer(ptr).SetCurrentFontDefault(gui.NewQFontFromPointer(fo))
NewQTextEditFromPointer(ptr).SetCurrentFontDefault(gui.NewQFontFromPointer(ff))
}
}
func (ptr *QTextEdit) ConnectSetCurrentFont(f func(fo *gui.QFont)) {
func (ptr *QTextEdit) ConnectSetCurrentFont(f func(ff *gui.QFont)) {
if ptr.Pointer() != nil {
if signal := qt.LendSignal(ptr.Pointer(), "setCurrentFont"); signal != nil {
qt.ConnectSignal(ptr.Pointer(), "setCurrentFont", func(fo *gui.QFont) {
signal.(func(*gui.QFont))(fo)
f(fo)
qt.ConnectSignal(ptr.Pointer(), "setCurrentFont", func(ff *gui.QFont) {
signal.(func(*gui.QFont))(ff)
f(ff)
})
} else {
qt.ConnectSignal(ptr.Pointer(), "setCurrentFont", f)
@ -93582,15 +93582,15 @@ func (ptr *QTextEdit) DisconnectSetCurrentFont() {
}
}
func (ptr *QTextEdit) SetCurrentFont(fo gui.QFont_ITF) {
func (ptr *QTextEdit) SetCurrentFont(ff gui.QFont_ITF) {
if ptr.Pointer() != nil {
C.QTextEdit_SetCurrentFont(ptr.Pointer(), gui.PointerFromQFont(fo))
C.QTextEdit_SetCurrentFont(ptr.Pointer(), gui.PointerFromQFont(ff))
}
}
func (ptr *QTextEdit) SetCurrentFontDefault(fo gui.QFont_ITF) {
func (ptr *QTextEdit) SetCurrentFontDefault(ff gui.QFont_ITF) {
if ptr.Pointer() != nil {
C.QTextEdit_SetCurrentFontDefault(ptr.Pointer(), gui.PointerFromQFont(fo))
C.QTextEdit_SetCurrentFontDefault(ptr.Pointer(), gui.PointerFromQFont(ff))
}
}
@ -94894,8 +94894,8 @@ func NewQTimeEdit(parent QWidget_ITF) *QTimeEdit {
return tmpValue
}
func NewQTimeEdit2(time core.QTime_ITF, parent QWidget_ITF) *QTimeEdit {
tmpValue := NewQTimeEditFromPointer(C.QTimeEdit_NewQTimeEdit2(core.PointerFromQTime(time), PointerFromQWidget(parent)))
func NewQTimeEdit2(ti core.QTime_ITF, parent QWidget_ITF) *QTimeEdit {
tmpValue := NewQTimeEditFromPointer(C.QTimeEdit_NewQTimeEdit2(core.PointerFromQTime(ti), PointerFromQWidget(parent)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
@ -95737,8 +95737,8 @@ func NewQToolBoxFromPointer(ptr unsafe.Pointer) (n *QToolBox) {
n.SetPointer(ptr)
return
}
func NewQToolBox(parent QWidget_ITF, fo core.Qt__WindowType) *QToolBox {
tmpValue := NewQToolBoxFromPointer(C.QToolBox_NewQToolBox(PointerFromQWidget(parent), C.longlong(fo)))
func NewQToolBox(parent QWidget_ITF, ff core.Qt__WindowType) *QToolBox {
tmpValue := NewQToolBoxFromPointer(C.QToolBox_NewQToolBox(PointerFromQWidget(parent), C.longlong(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
@ -103715,8 +103715,8 @@ func (ptr *QWidget) MouseGrabber() *QWidget {
return tmpValue
}
func NewQWidget(parent QWidget_ITF, fo core.Qt__WindowType) *QWidget {
tmpValue := NewQWidgetFromPointer(C.QWidget_NewQWidget(PointerFromQWidget(parent), C.longlong(fo)))
func NewQWidget(parent QWidget_ITF, ff core.Qt__WindowType) *QWidget {
tmpValue := NewQWidgetFromPointer(C.QWidget_NewQWidget(PointerFromQWidget(parent), C.longlong(ff)))
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
@ -105678,9 +105678,9 @@ func (ptr *QWidget) SetParent(parent QWidget_ITF) {
}
}
func (ptr *QWidget) SetParent2(parent QWidget_ITF, fo core.Qt__WindowType) {
func (ptr *QWidget) SetParent2(parent QWidget_ITF, ff core.Qt__WindowType) {
if ptr.Pointer() != nil {
C.QWidget_SetParent2(ptr.Pointer(), PointerFromQWidget(parent), C.longlong(fo))
C.QWidget_SetParent2(ptr.Pointer(), PointerFromQWidget(parent), C.longlong(ff))
}
}

46
widgets/widgets.h
View file

@ -1427,7 +1427,7 @@ void QDateEdit_DestroyQDateEditDefault(void* ptr);
void* QDateTimeEdit_NewQDateTimeEdit(void* parent);
void* QDateTimeEdit_NewQDateTimeEdit3(void* date, void* parent);
void* QDateTimeEdit_NewQDateTimeEdit2(void* datetime, void* parent);
void* QDateTimeEdit_NewQDateTimeEdit4(void* time, void* parent);
void* QDateTimeEdit_NewQDateTimeEdit4(void* ti, void* parent);
void QDateTimeEdit_Clear(void* ptr);
void QDateTimeEdit_ClearDefault(void* ptr);
void QDateTimeEdit_ClearMaximumDate(void* ptr);
@ -1460,13 +1460,13 @@ void QDateTimeEdit_SetMinimumDate(void* ptr, void* min);
void QDateTimeEdit_SetMinimumDateTime(void* ptr, void* dt);
void QDateTimeEdit_SetMinimumTime(void* ptr, void* min);
void QDateTimeEdit_SetSelectedSection(void* ptr, long long section);
void QDateTimeEdit_SetTime(void* ptr, void* time);
void QDateTimeEdit_SetTimeDefault(void* ptr, void* time);
void QDateTimeEdit_SetTime(void* ptr, void* ti);
void QDateTimeEdit_SetTimeDefault(void* ptr, void* ti);
void QDateTimeEdit_SetTimeRange(void* ptr, void* min, void* max);
void QDateTimeEdit_SetTimeSpec(void* ptr, long long spec);
void QDateTimeEdit_ConnectTimeChanged(void* ptr);
void QDateTimeEdit_DisconnectTimeChanged(void* ptr);
void QDateTimeEdit_TimeChanged(void* ptr, void* time);
void QDateTimeEdit_TimeChanged(void* ptr, void* ti);
void QDateTimeEdit_DestroyQDateTimeEdit(void* ptr);
void QDateTimeEdit_DestroyQDateTimeEditDefault(void* ptr);
void* QDateTimeEdit_CalendarWidget(void* ptr);
@ -1528,7 +1528,7 @@ char QDial_Wrapping(void* ptr);
int QDial_NotchSize(void* ptr);
double QDial_NotchTarget(void* ptr);
void QDial_InitStyleOption(void* ptr, void* option);
void* QDialog_NewQDialog(void* parent, long long fo);
void* QDialog_NewQDialog(void* parent, long long ff);
int QDialog_Exec(void* ptr);
int QDialog_ExecDefault(void* ptr);
void QDialog_Accept(void* ptr);
@ -2109,8 +2109,8 @@ void* QFontComboBox_NewQFontComboBox(void* parent);
void QFontComboBox_ConnectCurrentFontChanged(void* ptr);
void QFontComboBox_DisconnectCurrentFontChanged(void* ptr);
void QFontComboBox_CurrentFontChanged(void* ptr, void* font);
void QFontComboBox_SetCurrentFont(void* ptr, void* fo);
void QFontComboBox_SetCurrentFontDefault(void* ptr, void* fo);
void QFontComboBox_SetCurrentFont(void* ptr, void* ff);
void QFontComboBox_SetCurrentFontDefault(void* ptr, void* ff);
void QFontComboBox_SetFontFilters(void* ptr, long long filters);
void QFontComboBox_SetWritingSystem(void* ptr, long long vqf);
void QFontComboBox_DestroyQFontComboBox(void* ptr);
@ -2183,7 +2183,7 @@ int QFormLayout_RowCount(void* ptr);
int QFormLayout_VerticalSpacing(void* ptr);
;
;
void* QFrame_NewQFrame(void* parent, long long fo);
void* QFrame_NewQFrame(void* parent, long long ff);
void QFrame_SetFrameRect(void* ptr, void* vqr);
void QFrame_SetFrameShadow(void* ptr, long long vqf);
void QFrame_SetFrameShape(void* ptr, long long vqf);
@ -4166,8 +4166,8 @@ char QLCDNumber_SmallDecimalPoint(void* ptr);
double QLCDNumber_Value(void* ptr);
int QLCDNumber_DigitCount(void* ptr);
int QLCDNumber_IntValue(void* ptr);
void* QLabel_NewQLabel(void* parent, long long fo);
void* QLabel_NewQLabel2(struct QtWidgets_PackedString text, void* parent, long long fo);
void* QLabel_NewQLabel(void* parent, long long ff);
void* QLabel_NewQLabel2(struct QtWidgets_PackedString text, void* parent, long long ff);
void QLabel_Clear(void* ptr);
void QLabel_ClearDefault(void* ptr);
void QLabel_ConnectLinkActivated(void* ptr);
@ -4881,7 +4881,7 @@ char QMenuBar_IsDefaultUp(void* ptr);
char QMenuBar_IsNativeMenuBar(void* ptr);
void QMenuBar_InitStyleOption(void* ptr, void* option, void* action);
int QMessageBox_ButtonMask_Type();
void* QMessageBox_NewQMessageBox2(long long icon, struct QtWidgets_PackedString title, struct QtWidgets_PackedString text, long long buttons, void* parent, long long fo);
void* QMessageBox_NewQMessageBox2(long long icon, struct QtWidgets_PackedString title, struct QtWidgets_PackedString text, long long buttons, void* parent, long long ff);
void* QMessageBox_NewQMessageBox(void* parent);
long long QMessageBox_QMessageBox_Critical(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString text, long long buttons, long long defaultButton);
long long QMessageBox_QMessageBox_Information4(void* parent, struct QtWidgets_PackedString title, struct QtWidgets_PackedString text, long long button0, long long button1);
@ -4984,7 +4984,7 @@ void QMouseEventTransition_DeleteLaterDefault(void* ptr);
void QMouseEventTransition_DisconnectNotifyDefault(void* ptr, void* sign);
void QMouseEventTransition_TimerEventDefault(void* ptr, void* event);
void* QOpenGLWidget_GrabFramebuffer(void* ptr);
void* QOpenGLWidget_NewQOpenGLWidget(void* parent, long long fo);
void* QOpenGLWidget_NewQOpenGLWidget(void* parent, long long ff);
void QOpenGLWidget_ConnectAboutToCompose(void* ptr);
void QOpenGLWidget_DisconnectAboutToCompose(void* ptr);
void QOpenGLWidget_AboutToCompose(void* ptr);
@ -5258,8 +5258,8 @@ int QProgressBar_Maximum(void* ptr);
int QProgressBar_Minimum(void* ptr);
int QProgressBar_Value(void* ptr);
void QProgressBar_InitStyleOption(void* ptr, void* option);
void* QProgressDialog_NewQProgressDialog(void* parent, long long fo);
void* QProgressDialog_NewQProgressDialog2(struct QtWidgets_PackedString labelText, struct QtWidgets_PackedString cancelButtonText, int minimum, int maximum, void* parent, long long fo);
void* QProgressDialog_NewQProgressDialog(void* parent, long long ff);
void* QProgressDialog_NewQProgressDialog2(struct QtWidgets_PackedString labelText, struct QtWidgets_PackedString cancelButtonText, int minimum, int maximum, void* parent, long long ff);
void QProgressDialog_Cancel(void* ptr);
void QProgressDialog_CancelDefault(void* ptr);
void QProgressDialog_ConnectCanceled(void* ptr);
@ -5566,8 +5566,8 @@ int QSpinBox_SingleStep(void* ptr);
int QSpinBox_Value(void* ptr);
int QSpinBox_ValueFromText(void* ptr, struct QtWidgets_PackedString text);
int QSpinBox_ValueFromTextDefault(void* ptr, struct QtWidgets_PackedString text);
void* QSplashScreen_NewQSplashScreen2(void* parent, void* pixmap, long long fo);
void* QSplashScreen_NewQSplashScreen(void* pixmap, long long fo);
void* QSplashScreen_NewQSplashScreen2(void* parent, void* pixmap, long long ff);
void* QSplashScreen_NewQSplashScreen(void* pixmap, long long ff);
void QSplashScreen_ClearMessage(void* ptr);
void QSplashScreen_ClearMessageDefault(void* ptr);
void QSplashScreen_DrawContents(void* ptr, void* painter);
@ -6777,7 +6777,7 @@ void QTextEdit_DisconnectCopyAvailable(void* ptr);
void QTextEdit_CopyAvailable(void* ptr, char yes);
void QTextEdit_ConnectCurrentCharFormatChanged(void* ptr);
void QTextEdit_DisconnectCurrentCharFormatChanged(void* ptr);
void QTextEdit_CurrentCharFormatChanged(void* ptr, void* fo);
void QTextEdit_CurrentCharFormatChanged(void* ptr, void* ff);
void QTextEdit_ConnectCursorPositionChanged(void* ptr);
void QTextEdit_DisconnectCursorPositionChanged(void* ptr);
void QTextEdit_CursorPositionChanged(void* ptr);
@ -6811,8 +6811,8 @@ void QTextEdit_SetAlignment(void* ptr, long long a);
void QTextEdit_SetAlignmentDefault(void* ptr, long long a);
void QTextEdit_SetAutoFormatting(void* ptr, long long features);
void QTextEdit_SetCurrentCharFormat(void* ptr, void* format);
void QTextEdit_SetCurrentFont(void* ptr, void* fo);
void QTextEdit_SetCurrentFontDefault(void* ptr, void* fo);
void QTextEdit_SetCurrentFont(void* ptr, void* ff);
void QTextEdit_SetCurrentFontDefault(void* ptr, void* ff);
void QTextEdit_SetCursorWidth(void* ptr, int width);
void QTextEdit_SetDocument(void* ptr, void* document);
void QTextEdit_SetDocumentTitle(void* ptr, struct QtWidgets_PackedString title);
@ -6908,7 +6908,7 @@ void QTileRules_SetHorizontal(void* ptr, long long vqt);
long long QTileRules_Vertical(void* ptr);
void QTileRules_SetVertical(void* ptr, long long vqt);
void* QTimeEdit_NewQTimeEdit(void* parent);
void* QTimeEdit_NewQTimeEdit2(void* time, void* parent);
void* QTimeEdit_NewQTimeEdit2(void* ti, void* parent);
void QTimeEdit_DestroyQTimeEdit(void* ptr);
void QTimeEdit_DestroyQTimeEditDefault(void* ptr);
void* QToolBar_AddAction2(void* ptr, void* icon, struct QtWidgets_PackedString text);
@ -6968,7 +6968,7 @@ char QToolBar_IsAreaAllowed(void* ptr, long long area);
char QToolBar_IsFloatable(void* ptr);
char QToolBar_IsFloating(void* ptr);
char QToolBar_IsMovable(void* ptr);
void* QToolBox_NewQToolBox(void* parent, long long fo);
void* QToolBox_NewQToolBox(void* parent, long long ff);
int QToolBox_AddItem2(void* ptr, void* w, struct QtWidgets_PackedString text);
int QToolBox_AddItem(void* ptr, void* widget, void* iconSet, struct QtWidgets_PackedString text);
int QToolBox_InsertItem(void* ptr, int index, void* widget, void* icon, struct QtWidgets_PackedString text);
@ -7547,7 +7547,7 @@ void* QWidget_QWidget_CreateWindowContainer(void* window, void* parent, long lon
void* QWidget_QWidget_Find(uintptr_t id);
void* QWidget_QWidget_KeyboardGrabber();
void* QWidget_QWidget_MouseGrabber();
void* QWidget_NewQWidget(void* parent, long long fo);
void* QWidget_NewQWidget(void* parent, long long ff);
char QWidget_Close(void* ptr);
char QWidget_CloseDefault(void* ptr);
char QWidget_Event(void* ptr, void* event);
@ -7695,7 +7695,7 @@ void QWidget_SetMinimumWidth(void* ptr, int minw);
void QWidget_SetMouseTracking(void* ptr, char enable);
void QWidget_SetPalette(void* ptr, void* vqp);
void QWidget_SetParent(void* ptr, void* parent);
void QWidget_SetParent2(void* ptr, void* parent, long long fo);
void QWidget_SetParent2(void* ptr, void* parent, long long ff);
void QWidget_SetShortcutAutoRepeat(void* ptr, int id, char enable);
void QWidget_SetShortcutEnabled(void* ptr, int id, char enable);
void QWidget_SetSizeIncrement(void* ptr, void* vqs);