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

support the readData function

Browse source
This commit is contained in:
therecipe 2017-01-11 16:18:44 +01:00
parent 8d6e005dd3
commit a38697d6be
56 changed files with 1245 additions and 11 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
androidextras/androidextras.go
View file

@ -4,6 +4,7 @@ package androidextras
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "androidextras_android.h"
import "C"
import (

1
androidextras/androidextras_android.go
View file

@ -4,6 +4,7 @@ package androidextras
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "androidextras_android.h"
import "C"
import (

11
bluetooth/bluetooth.cpp
View file

@ -1415,6 +1415,7 @@ public:
bool canReadLine() const { return callbackQBluetoothSocket_CanReadLine(const_cast<MyQBluetoothSocket*>(this)) != 0; };
void close() { callbackQBluetoothSocket_Close(this); };
bool isSequential() const { return callbackQBluetoothSocket_IsSequential(const_cast<MyQBluetoothSocket*>(this)) != 0; };
qint64 readData(char * data, qint64 maxSize) { QtBluetooth_PackedString dataPacked = { data, maxSize };return callbackQBluetoothSocket_ReadData(this, dataPacked, maxSize); };
qint64 writeData(const char * data, qint64 maxSize) { QtBluetooth_PackedString dataPacked = { const_cast<char*>(data), maxSize };return callbackQBluetoothSocket_WriteData(this, dataPacked, maxSize); };
~MyQBluetoothSocket() { callbackQBluetoothSocket_DestroyQBluetoothSocket(this); };
bool atEnd() const { return callbackQBluetoothSocket_AtEnd(const_cast<MyQBluetoothSocket*>(this)) != 0; };
@ -1632,6 +1633,16 @@ long long QBluetoothSocket_PreferredSecurityFlags(void* ptr)
return static_cast<QBluetoothSocket*>(ptr)->preferredSecurityFlags();
}
long long QBluetoothSocket_ReadData(void* ptr, char* data, long long maxSize)
{
return static_cast<QBluetoothSocket*>(ptr)->readData(data, maxSize);
}
long long QBluetoothSocket_ReadDataDefault(void* ptr, char* data, long long maxSize)
{
return static_cast<QBluetoothSocket*>(ptr)->QBluetoothSocket::readData(data, maxSize);
}
void QBluetoothSocket_SetPreferredSecurityFlags(void* ptr, long long flags)
{
static_cast<QBluetoothSocket*>(ptr)->setPreferredSecurityFlags(static_cast<QBluetooth::Security>(flags));

61
bluetooth/bluetooth.go
View file

@ -4,6 +4,7 @@ package bluetooth
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "bluetooth.h"
import "C"
import (
@ -12,6 +13,7 @@ import (
"github.com/therecipe/qt/core"
"github.com/therecipe/qt/network"
"runtime"
"strings"
"unsafe"
)
@ -4221,6 +4223,65 @@ func (ptr *QBluetoothSocket) PreferredSecurityFlags() QBluetooth__Security {
return 0
}
//export callbackQBluetoothSocket_ReadData
func callbackQBluetoothSocket_ReadData(ptr unsafe.Pointer, data C.struct_QtBluetooth_PackedString, maxSize C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QBluetoothSocket::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(maxSize)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
var retS = cGoUnpackString(data)
var ret = C.longlong(NewQBluetoothSocketFromPointer(ptr).ReadDataDefault(&retS, int64(maxSize)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
func (ptr *QBluetoothSocket) ConnectReadData(f func(data *string, maxSize int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QBluetoothSocket::readData", f)
}
}
func (ptr *QBluetoothSocket) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QBluetoothSocket::readData")
}
}
func (ptr *QBluetoothSocket) ReadData(data *string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxSize)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QBluetoothSocket_ReadData(ptr.Pointer(), dataC, C.longlong(maxSize)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QBluetoothSocket) ReadDataDefault(data *string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxSize)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QBluetoothSocket_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(maxSize)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QBluetoothSocket) SetPreferredSecurityFlags(flags QBluetooth__Security) {
if ptr.Pointer() != nil {
C.QBluetoothSocket_SetPreferredSecurityFlags(ptr.Pointer(), C.longlong(flags))

2
bluetooth/bluetooth.h
View file

@ -306,6 +306,8 @@ void* QBluetoothSocket_PeerAddress(void* ptr);
struct QtBluetooth_PackedString QBluetoothSocket_PeerName(void* ptr);
unsigned short QBluetoothSocket_PeerPort(void* ptr);
long long QBluetoothSocket_PreferredSecurityFlags(void* ptr);
long long QBluetoothSocket_ReadData(void* ptr, char* data, long long maxSize);
long long QBluetoothSocket_ReadDataDefault(void* ptr, char* data, long long maxSize);
void QBluetoothSocket_SetPreferredSecurityFlags(void* ptr, long long flags);
char QBluetoothSocket_SetSocketDescriptor(void* ptr, int socketDescriptor, long long socketType, long long socketState, long long openMode);
void QBluetoothSocket_SetSocketError(void* ptr, long long error_);

1
charts/charts.go
View file

@ -4,6 +4,7 @@ package charts
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "charts.h"
import "C"
import (

73
core/core.cpp
View file

@ -3702,6 +3702,7 @@ public:
void close() { callbackQBuffer_Close(this); };
bool open(QIODevice::OpenMode flags) { return callbackQBuffer_Open(this, flags) != 0; };
qint64 pos() const { return callbackQBuffer_Pos(const_cast<MyQBuffer*>(this)); };
qint64 readData(char * data, qint64 len) { QtCore_PackedString dataPacked = { data, len };return callbackQBuffer_ReadData(this, dataPacked, len); };
bool seek(qint64 pos) { return callbackQBuffer_Seek(this, pos) != 0; };
qint64 size() const { return callbackQBuffer_Size(const_cast<MyQBuffer*>(this)); };
qint64 writeData(const char * data, qint64 len) { QtCore_PackedString dataPacked = { const_cast<char*>(data), len };return callbackQBuffer_WriteData(this, dataPacked, len); };
@ -3798,6 +3799,16 @@ long long QBuffer_PosDefault(void* ptr)
return static_cast<QBuffer*>(ptr)->QBuffer::pos();
}
long long QBuffer_ReadData(void* ptr, char* data, long long len)
{
return static_cast<QBuffer*>(ptr)->readData(data, len);
}
long long QBuffer_ReadDataDefault(void* ptr, char* data, long long len)
{
return static_cast<QBuffer*>(ptr)->QBuffer::readData(data, len);
}
char QBuffer_Seek(void* ptr, long long pos)
{
return static_cast<QBuffer*>(ptr)->seek(pos);
@ -7406,6 +7417,7 @@ public:
void close() { callbackQFile_Close(this); };
bool isSequential() const { return callbackQFile_IsSequential(const_cast<MyQFile*>(this)) != 0; };
qint64 pos() const { return callbackQFile_Pos(const_cast<MyQFile*>(this)); };
qint64 readData(char * data, qint64 len) { QtCore_PackedString dataPacked = { data, len };return callbackQFile_ReadData(this, dataPacked, len); };
qint64 readLineData(char * data, qint64 maxlen) { QtCore_PackedString dataPacked = { data, maxlen };return callbackQFile_ReadLineData(this, dataPacked, maxlen); };
qint64 writeData(const char * data, qint64 len) { QtCore_PackedString dataPacked = { const_cast<char*>(data), len };return callbackQFile_WriteData(this, dataPacked, len); };
qint64 bytesAvailable() const { return callbackQFile_BytesAvailable(const_cast<MyQFile*>(this)); };
@ -7660,6 +7672,16 @@ long long QFile_PosDefault(void* ptr)
return static_cast<QFile*>(ptr)->QFile::pos();
}
long long QFile_ReadData(void* ptr, char* data, long long len)
{
return static_cast<QFile*>(ptr)->readData(data, len);
}
long long QFile_ReadDataDefault(void* ptr, char* data, long long len)
{
return static_cast<QFile*>(ptr)->QFile::readData(data, len);
}
long long QFile_ReadLineData(void* ptr, char* data, long long maxlen)
{
return static_cast<QFile*>(ptr)->readLineData(data, maxlen);
@ -7840,6 +7862,7 @@ public:
bool isSequential() const { return callbackQFileDevice_IsSequential(const_cast<MyQFileDevice*>(this)) != 0; };
Permissions permissions() const { return static_cast<QFileDevice::Permission>(callbackQFileDevice_Permissions(const_cast<MyQFileDevice*>(this))); };
qint64 pos() const { return callbackQFileDevice_Pos(const_cast<MyQFileDevice*>(this)); };
qint64 readData(char * data, qint64 len) { QtCore_PackedString dataPacked = { data, len };return callbackQFileDevice_ReadData(this, dataPacked, len); };
qint64 readLineData(char * data, qint64 maxlen) { QtCore_PackedString dataPacked = { data, maxlen };return callbackQFileDevice_ReadLineData(this, dataPacked, maxlen); };
bool resize(qint64 sz) { return callbackQFileDevice_Resize(this, sz) != 0; };
bool setPermissions(QFileDevice::Permissions permissions) { return callbackQFileDevice_SetPermissions(this, permissions) != 0; };
@ -7953,6 +7976,16 @@ long long QFileDevice_PosDefault(void* ptr)
return static_cast<QFileDevice*>(ptr)->QFileDevice::pos();
}
long long QFileDevice_ReadData(void* ptr, char* data, long long len)
{
return static_cast<QFileDevice*>(ptr)->readData(data, len);
}
long long QFileDevice_ReadDataDefault(void* ptr, char* data, long long len)
{
return static_cast<QFileDevice*>(ptr)->QFileDevice::readData(data, len);
}
long long QFileDevice_ReadLineData(void* ptr, char* data, long long maxlen)
{
return static_cast<QFileDevice*>(ptr)->readLineData(data, maxlen);
@ -9117,6 +9150,8 @@ void* QHistoryState_MetaObjectDefault(void* ptr)
class MyQIODevice: public QIODevice
{
public:
MyQIODevice() : QIODevice() {};
MyQIODevice(QObject *parent) : QIODevice(parent) {};
void Signal_AboutToClose() { callbackQIODevice_AboutToClose(this); };
bool atEnd() const { return callbackQIODevice_AtEnd(const_cast<MyQIODevice*>(this)) != 0; };
qint64 bytesAvailable() const { return callbackQIODevice_BytesAvailable(const_cast<MyQIODevice*>(this)); };
@ -9130,6 +9165,7 @@ public:
bool open(QIODevice::OpenMode mode) { return callbackQIODevice_Open(this, mode) != 0; };
qint64 pos() const { return callbackQIODevice_Pos(const_cast<MyQIODevice*>(this)); };
void Signal_ReadChannelFinished() { callbackQIODevice_ReadChannelFinished(this); };
qint64 readData(char * data, qint64 maxSize) { QtCore_PackedString dataPacked = { data, maxSize };return callbackQIODevice_ReadData(this, dataPacked, maxSize); };
qint64 readLineData(char * data, qint64 maxSize) { QtCore_PackedString dataPacked = { data, maxSize };return callbackQIODevice_ReadLineData(this, dataPacked, maxSize); };
void Signal_ReadyRead() { callbackQIODevice_ReadyRead(this); };
bool reset() { return callbackQIODevice_Reset(this) != 0; };
@ -9160,6 +9196,16 @@ char QIODevice_PutChar(void* ptr, char* c)
return static_cast<QIODevice*>(ptr)->putChar(*c);
}
void* QIODevice_NewQIODevice()
{
return new MyQIODevice();
}
void* QIODevice_NewQIODevice2(void* parent)
{
return new MyQIODevice(static_cast<QObject*>(parent));
}
void QIODevice_ConnectAboutToClose(void* ptr)
{
QObject::connect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)()>(&QIODevice::aboutToClose), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)()>(&MyQIODevice::Signal_AboutToClose));
@ -9395,6 +9441,11 @@ void QIODevice_ReadChannelFinished(void* ptr)
static_cast<QIODevice*>(ptr)->readChannelFinished();
}
long long QIODevice_ReadData(void* ptr, char* data, long long maxSize)
{
return static_cast<QIODevice*>(ptr)->readData(data, maxSize);
}
void* QIODevice_ReadLine2(void* ptr, long long maxSize)
{
return new QByteArray(static_cast<QIODevice*>(ptr)->readLine(maxSize));
@ -16371,6 +16422,7 @@ public:
bool isSequential() const { return callbackQSaveFile_IsSequential(const_cast<MyQSaveFile*>(this)) != 0; };
Permissions permissions() const { return static_cast<QFileDevice::Permission>(callbackQSaveFile_Permissions(const_cast<MyQSaveFile*>(this))); };
qint64 pos() const { return callbackQSaveFile_Pos(const_cast<MyQSaveFile*>(this)); };
qint64 readData(char * data, qint64 len) { QtCore_PackedString dataPacked = { data, len };return callbackQSaveFile_ReadData(this, dataPacked, len); };
qint64 readLineData(char * data, qint64 maxlen) { QtCore_PackedString dataPacked = { data, maxlen };return callbackQSaveFile_ReadLineData(this, dataPacked, maxlen); };
bool resize(qint64 sz) { return callbackQSaveFile_Resize(this, sz) != 0; };
bool setPermissions(QFileDevice::Permissions permissions) { return callbackQSaveFile_SetPermissions(this, permissions) != 0; };
@ -16527,6 +16579,16 @@ long long QSaveFile_PosDefault(void* ptr)
return static_cast<QSaveFile*>(ptr)->QSaveFile::pos();
}
long long QSaveFile_ReadData(void* ptr, char* data, long long len)
{
return static_cast<QSaveFile*>(ptr)->readData(data, len);
}
long long QSaveFile_ReadDataDefault(void* ptr, char* data, long long len)
{
return static_cast<QSaveFile*>(ptr)->QSaveFile::readData(data, len);
}
long long QSaveFile_ReadLineData(void* ptr, char* data, long long maxlen)
{
return static_cast<QSaveFile*>(ptr)->readLineData(data, maxlen);
@ -20982,6 +21044,7 @@ public:
void close() { callbackQTemporaryFile_Close(this); };
bool isSequential() const { return callbackQTemporaryFile_IsSequential(const_cast<MyQTemporaryFile*>(this)) != 0; };
qint64 pos() const { return callbackQTemporaryFile_Pos(const_cast<MyQTemporaryFile*>(this)); };
qint64 readData(char * data, qint64 len) { QtCore_PackedString dataPacked = { data, len };return callbackQTemporaryFile_ReadData(this, dataPacked, len); };
qint64 readLineData(char * data, qint64 maxlen) { QtCore_PackedString dataPacked = { data, maxlen };return callbackQTemporaryFile_ReadLineData(this, dataPacked, maxlen); };
qint64 writeData(const char * data, qint64 len) { QtCore_PackedString dataPacked = { const_cast<char*>(data), len };return callbackQTemporaryFile_WriteData(this, dataPacked, len); };
qint64 bytesAvailable() const { return callbackQTemporaryFile_BytesAvailable(const_cast<MyQTemporaryFile*>(this)); };
@ -21171,6 +21234,16 @@ long long QTemporaryFile_PosDefault(void* ptr)
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::pos();
}
long long QTemporaryFile_ReadData(void* ptr, char* data, long long len)
{
return static_cast<QTemporaryFile*>(ptr)->readData(data, len);
}
long long QTemporaryFile_ReadDataDefault(void* ptr, char* data, long long len)
{
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::readData(data, len);
}
long long QTemporaryFile_ReadLineData(void* ptr, char* data, long long maxlen)
{
return static_cast<QTemporaryFile*>(ptr)->readLineData(data, maxlen);

354
core/core.go
View file

@ -4,6 +4,7 @@ package core
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "core.h"
import "C"
import (
@ -11527,6 +11528,65 @@ func (ptr *QBuffer) PosDefault() int64 {
return 0
}
//export callbackQBuffer_ReadData
func callbackQBuffer_ReadData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, len C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QBuffer::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(len)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
var retS = cGoUnpackString(data)
var ret = C.longlong(NewQBufferFromPointer(ptr).ReadDataDefault(&retS, int64(len)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
func (ptr *QBuffer) ConnectReadData(f func(data *string, len int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QBuffer::readData", f)
}
}
func (ptr *QBuffer) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QBuffer::readData")
}
}
func (ptr *QBuffer) ReadData(data *string, len int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(len)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QBuffer_ReadData(ptr.Pointer(), dataC, C.longlong(len)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QBuffer) ReadDataDefault(data *string, len int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(len)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QBuffer_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(len)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
//export callbackQBuffer_Seek
func callbackQBuffer_Seek(ptr unsafe.Pointer, pos C.longlong) C.char {
@ -21041,6 +21101,65 @@ func (ptr *QFile) PosDefault() int64 {
return 0
}
//export callbackQFile_ReadData
func callbackQFile_ReadData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, len C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QFile::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(len)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
var retS = cGoUnpackString(data)
var ret = C.longlong(NewQFileFromPointer(ptr).ReadDataDefault(&retS, int64(len)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
func (ptr *QFile) ConnectReadData(f func(data *string, len int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QFile::readData", f)
}
}
func (ptr *QFile) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QFile::readData")
}
}
func (ptr *QFile) ReadData(data *string, len int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(len)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QFile_ReadData(ptr.Pointer(), dataC, C.longlong(len)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QFile) ReadDataDefault(data *string, len int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(len)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QFile_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(len)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
//export callbackQFile_ReadLineData
func callbackQFile_ReadLineData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, maxlen C.longlong) C.longlong {
@ -22076,6 +22195,65 @@ func (ptr *QFileDevice) PosDefault() int64 {
return 0
}
//export callbackQFileDevice_ReadData
func callbackQFileDevice_ReadData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, len C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QFileDevice::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(len)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
var retS = cGoUnpackString(data)
var ret = C.longlong(NewQFileDeviceFromPointer(ptr).ReadDataDefault(&retS, int64(len)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
func (ptr *QFileDevice) ConnectReadData(f func(data *string, len int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QFileDevice::readData", f)
}
}
func (ptr *QFileDevice) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QFileDevice::readData")
}
}
func (ptr *QFileDevice) ReadData(data *string, len int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(len)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QFileDevice_ReadData(ptr.Pointer(), dataC, C.longlong(len)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QFileDevice) ReadDataDefault(data *string, len int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(len)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QFileDevice_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(len)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
//export callbackQFileDevice_ReadLineData
func callbackQFileDevice_ReadLineData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, maxlen C.longlong) C.longlong {
@ -25911,6 +26089,22 @@ func (ptr *QIODevice) PutChar(c string) bool {
return false
}
func NewQIODevice() *QIODevice {
var tmpValue = NewQIODeviceFromPointer(C.QIODevice_NewQIODevice())
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
}
return tmpValue
}
func NewQIODevice2(parent QObject_ITF) *QIODevice {
var tmpValue = NewQIODeviceFromPointer(C.QIODevice_NewQIODevice2(PointerFromQObject(parent)))
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
}
return tmpValue
}
//export callbackQIODevice_AboutToClose
func callbackQIODevice_AboutToClose(ptr unsafe.Pointer) {
@ -26479,6 +26673,48 @@ func (ptr *QIODevice) ReadChannelFinished() {
}
}
//export callbackQIODevice_ReadData
func callbackQIODevice_ReadData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, maxSize C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QIODevice::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(maxSize)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
return C.longlong(0)
}
func (ptr *QIODevice) ConnectReadData(f func(data *string, maxSize int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QIODevice::readData", f)
}
}
func (ptr *QIODevice) DisconnectReadData(data *string, maxSize int64) {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QIODevice::readData")
}
}
func (ptr *QIODevice) ReadData(data *string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxSize)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QIODevice_ReadData(ptr.Pointer(), dataC, C.longlong(maxSize)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QIODevice) ReadLine2(maxSize int64) *QByteArray {
if ptr.Pointer() != nil {
var tmpValue = NewQByteArrayFromPointer(C.QIODevice_ReadLine2(ptr.Pointer(), C.longlong(maxSize)))
@ -45746,6 +45982,65 @@ func (ptr *QSaveFile) PosDefault() int64 {
return 0
}
//export callbackQSaveFile_ReadData
func callbackQSaveFile_ReadData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, len C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSaveFile::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(len)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
var retS = cGoUnpackString(data)
var ret = C.longlong(NewQSaveFileFromPointer(ptr).ReadDataDefault(&retS, int64(len)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
func (ptr *QSaveFile) ConnectReadData(f func(data *string, len int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSaveFile::readData", f)
}
}
func (ptr *QSaveFile) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSaveFile::readData")
}
}
func (ptr *QSaveFile) ReadData(data *string, len int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(len)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QSaveFile_ReadData(ptr.Pointer(), dataC, C.longlong(len)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QSaveFile) ReadDataDefault(data *string, len int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(len)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QSaveFile_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(len)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
//export callbackQSaveFile_ReadLineData
func callbackQSaveFile_ReadLineData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, maxlen C.longlong) C.longlong {
@ -58641,6 +58936,65 @@ func (ptr *QTemporaryFile) PosDefault() int64 {
return 0
}
//export callbackQTemporaryFile_ReadData
func callbackQTemporaryFile_ReadData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, len C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QTemporaryFile::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(len)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
var retS = cGoUnpackString(data)
var ret = C.longlong(NewQTemporaryFileFromPointer(ptr).ReadDataDefault(&retS, int64(len)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
func (ptr *QTemporaryFile) ConnectReadData(f func(data *string, len int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QTemporaryFile::readData", f)
}
}
func (ptr *QTemporaryFile) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QTemporaryFile::readData")
}
}
func (ptr *QTemporaryFile) ReadData(data *string, len int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(len)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QTemporaryFile_ReadData(ptr.Pointer(), dataC, C.longlong(len)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QTemporaryFile) ReadDataDefault(data *string, len int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(len)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QTemporaryFile_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(len)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
//export callbackQTemporaryFile_ReadLineData
func callbackQTemporaryFile_ReadLineData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, maxlen C.longlong) C.longlong {

13
core/core.h
View file

@ -672,6 +672,8 @@ char QBuffer_Open(void* ptr, long long flags);
char QBuffer_OpenDefault(void* ptr, long long flags);
long long QBuffer_Pos(void* ptr);
long long QBuffer_PosDefault(void* ptr);
long long QBuffer_ReadData(void* ptr, char* data, long long len);
long long QBuffer_ReadDataDefault(void* ptr, char* data, long long len);
char QBuffer_Seek(void* ptr, long long pos);
char QBuffer_SeekDefault(void* ptr, long long pos);
void QBuffer_SetBuffer(void* ptr, void* byteArray);
@ -1424,6 +1426,8 @@ char QFile_IsSequential(void* ptr);
char QFile_IsSequentialDefault(void* ptr);
long long QFile_Pos(void* ptr);
long long QFile_PosDefault(void* ptr);
long long QFile_ReadData(void* ptr, char* data, long long len);
long long QFile_ReadDataDefault(void* ptr, char* data, long long len);
long long QFile_ReadLineData(void* ptr, char* data, long long maxlen);
long long QFile_ReadLineDataDefault(void* ptr, char* data, long long maxlen);
long long QFile_WriteData(void* ptr, char* data, long long len);
@ -1476,6 +1480,8 @@ long long QFileDevice_Permissions(void* ptr);
long long QFileDevice_PermissionsDefault(void* ptr);
long long QFileDevice_Pos(void* ptr);
long long QFileDevice_PosDefault(void* ptr);
long long QFileDevice_ReadData(void* ptr, char* data, long long len);
long long QFileDevice_ReadDataDefault(void* ptr, char* data, long long len);
long long QFileDevice_ReadLineData(void* ptr, char* data, long long maxlen);
long long QFileDevice_ReadLineDataDefault(void* ptr, char* data, long long maxlen);
char QFileDevice_Resize(void* ptr, long long sz);
@ -1699,6 +1705,8 @@ void* QHistoryState_MetaObject(void* ptr);
void* QHistoryState_MetaObjectDefault(void* ptr);
char QIODevice_GetChar(void* ptr, char* c);
char QIODevice_PutChar(void* ptr, char* c);
void* QIODevice_NewQIODevice();
void* QIODevice_NewQIODevice2(void* parent);
void QIODevice_ConnectAboutToClose(void* ptr);
void QIODevice_DisconnectAboutToClose(void* ptr);
void QIODevice_AboutToClose(void* ptr);
@ -1746,6 +1754,7 @@ int QIODevice_ReadChannelCount(void* ptr);
void QIODevice_ConnectReadChannelFinished(void* ptr);
void QIODevice_DisconnectReadChannelFinished(void* ptr);
void QIODevice_ReadChannelFinished(void* ptr);
long long QIODevice_ReadData(void* ptr, char* data, long long maxSize);
void* QIODevice_ReadLine2(void* ptr, long long maxSize);
long long QIODevice_ReadLine(void* ptr, char* data, long long maxSize);
long long QIODevice_ReadLineData(void* ptr, char* data, long long maxSize);
@ -3127,6 +3136,8 @@ long long QSaveFile_Permissions(void* ptr);
long long QSaveFile_PermissionsDefault(void* ptr);
long long QSaveFile_Pos(void* ptr);
long long QSaveFile_PosDefault(void* ptr);
long long QSaveFile_ReadData(void* ptr, char* data, long long len);
long long QSaveFile_ReadDataDefault(void* ptr, char* data, long long len);
long long QSaveFile_ReadLineData(void* ptr, char* data, long long maxlen);
long long QSaveFile_ReadLineDataDefault(void* ptr, char* data, long long maxlen);
char QSaveFile_Resize(void* ptr, long long sz);
@ -3978,6 +3989,8 @@ char QTemporaryFile_IsSequential(void* ptr);
char QTemporaryFile_IsSequentialDefault(void* ptr);
long long QTemporaryFile_Pos(void* ptr);
long long QTemporaryFile_PosDefault(void* ptr);
long long QTemporaryFile_ReadData(void* ptr, char* data, long long len);
long long QTemporaryFile_ReadDataDefault(void* ptr, char* data, long long len);
long long QTemporaryFile_ReadLineData(void* ptr, char* data, long long maxlen);
long long QTemporaryFile_ReadLineDataDefault(void* ptr, char* data, long long maxlen);
long long QTemporaryFile_WriteData(void* ptr, char* data, long long len);

1
datavisualization/datavisualization.go
View file

@ -4,6 +4,7 @@ package datavisualization
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "datavisualization.h"
import "C"
import (

1
dbus/dbus.go
View file

@ -4,6 +4,7 @@ package dbus
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "dbus.h"
import "C"
import (

1
designer/designer.go
View file

@ -4,6 +4,7 @@ package designer
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "designer.h"
import "C"
import (

1
gamepad/gamepad.go
View file

@ -4,6 +4,7 @@ package gamepad
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "gamepad.h"
import "C"
import (

1
gui/gui.go
View file

@ -4,6 +4,7 @@ package gui
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "gui.h"
import "C"
import (

1
help/help.go
View file

@ -4,6 +4,7 @@ package help
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "help.h"
import "C"
import (

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

@ -53,8 +53,12 @@ func GoInputParametersForCallback(function *parser.Function) string {
var input = make([]string, len(function.Parameters))
for i, parameter := range function.Parameters {
if function.Name == "readData" && strings.HasPrefix(cgoOutput(parameter.Name, parameter.Value, function), "cGoUnpackString") {
input[i] = "&retS"
} else {
input[i] = cgoOutput(parameter.Name, parameter.Value, function)
}
}
return strings.Join(input, ", ")
}

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

@ -20,6 +20,10 @@ func GoInput(name, value string, f *parser.Function) string {
return fmt.Sprintf("C.CString(strings.Join(%v, \"|\"))", name)
}
if value == "char" && strings.Count(vOld, "*") == 1 && f.Name == "readData" {
return fmt.Sprintf("C.CString(strings.Repeat(\"0\", int(%v)))", parser.CleanName(f.Parameters[1].Name, f.Parameters[1].Value))
}
return fmt.Sprintf("C.CString(%v)", name)
}

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

@ -23,6 +23,10 @@ func goType(f *parser.Function, value string) string {
return "error"
}
if value == "char" && strings.Count(vOld, "*") == 1 && f.Name == "readData" {
return "*string"
}
return "string"
}

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

@ -181,8 +181,6 @@ func (f *Function) IsSupported() bool {
f.Name == "surfaceHandle", //QQuickWindow && QQuickView //unsupported_cppType(QPlatformSurface)
f.Name == "readData", f.Name == "QNetworkReply", //TODO: char*
f.Name == "QDesignerFormWindowInterface" || f.Name == "QDesignerFormWindowManagerInterface" || f.Name == "QDesignerWidgetBoxInterface", //unimplemented virtual
f.Fullname == "QNdefNfcSmartPosterRecord::titleRecords", //T<T> output with unsupported output for *_atList
@ -264,7 +262,9 @@ func (f *Function) IsSupportedDefault() bool {
"QSimpleXmlNodeModel::name",
"QSimpleXmlNodeModel::attributes", "QAbstractXmlNodeModel::attributes":
"QSimpleXmlNodeModel::attributes", "QAbstractXmlNodeModel::attributes",
"QNetworkReply::readData":
{
return false

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

@ -157,10 +157,14 @@ func goFunctionBody(function *parser.Function) string {
default:
{
if function.Name == "readData" && len(function.Parameters) == 2 {
return fmt.Sprintf("var ret = %v\nif ret > 0 {\n*data = C.GoStringN(dataC, C.int(ret))\n}\nreturn ret", body)
} else {
return fmt.Sprintf("return %v", body)
}
}
}
}
return body
}())
@ -183,9 +187,16 @@ func goFunctionBody(function *parser.Function) string {
if converter.GoHeaderOutput(function) == "" {
fmt.Fprintf(bb, "signal.(%v)(%v)", converter.GoHeaderInputSignalFunction(function), converter.GoInputParametersForCallback(function))
} else {
if function.Name == "readData" && len(function.Parameters) == 2 {
fmt.Fprint(bb, "var retS = cGoUnpackString(data)\n")
fmt.Fprintf(bb, "var ret = %v\n", converter.GoInput(fmt.Sprintf("signal.(%v)(%v)", converter.GoHeaderInputSignalFunction(function), converter.GoInputParametersForCallback(function)), function.Output, function))
fmt.Fprint(bb, "if ret > 0 {\nC.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))\n}\n")
fmt.Fprint(bb, "return ret")
} else {
fmt.Fprintf(bb, "return %v", converter.GoInput(fmt.Sprintf("signal.(%v)(%v)", converter.GoHeaderInputSignalFunction(function), converter.GoInputParametersForCallback(function)), function.Output, function))
}
}
fmt.Fprintf(bb, "\n}%v\n",
func() string {
@ -204,7 +215,14 @@ func goFunctionBody(function *parser.Function) string {
}
} else {
if function.Virtual == parser.IMPURE && function.IsSupportedDefault() {
if function.Name == "readData" && len(function.Parameters) == 2 {
fmt.Fprint(bb, "var retS = cGoUnpackString(data)\n")
fmt.Fprintf(bb, "var ret = %v\n", converter.GoInput(fmt.Sprintf("New%vFromPointer(ptr).%v%vDefault(%v)", strings.Title(function.ClassName()), strings.Replace(strings.Title(function.Name), parser.TILDE, "Destroy", -1), function.OverloadNumber, converter.GoInputParametersForCallback(function)), function.Output, function))
fmt.Fprint(bb, "if ret > 0 {\nC.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))\n}\n")
fmt.Fprint(bb, "return ret")
} else {
fmt.Fprintf(bb, "\nreturn %v", converter.GoInput(fmt.Sprintf("New%vFromPointer(ptr).%v%vDefault(%v)", strings.Title(function.ClassName()), strings.Replace(strings.Title(function.Name), parser.TILDE, "Destroy", -1), function.OverloadNumber, converter.GoInputParametersForCallback(function)), function.Output, function))
}
} else {
if converter.GoOutputParametersFromCFailed(function) == "nil" && !parser.State.Minimal {
var (

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

@ -305,6 +305,7 @@ package %v
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "%v.h"
import "C"
import (

1
location/location.go
View file

@ -4,6 +4,7 @@ package location
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "location.h"
import "C"
import (

1
macextras/macextras.go
View file

@ -4,6 +4,7 @@ package macextras
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "macextras.h"
import "C"
import (

5
multimedia/multimedia.go
View file

@ -4,6 +4,7 @@ package multimedia
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "multimedia.h"
import "C"
import (
@ -3556,7 +3557,7 @@ func callbackQAudioDecoderControl_SourceDevice(ptr unsafe.Pointer) unsafe.Pointe
return core.PointerFromQIODevice(signal.(func() *core.QIODevice)())
}
return core.PointerFromQIODevice(nil)
return core.PointerFromQIODevice(core.NewQIODevice())
}
func (ptr *QAudioDecoderControl) ConnectSourceDevice(f func() *core.QIODevice) {
@ -33739,7 +33740,7 @@ func callbackQMediaPlayerControl_MediaStream(ptr unsafe.Pointer) unsafe.Pointer
return core.PointerFromQIODevice(signal.(func() *core.QIODevice)())
}
return core.PointerFromQIODevice(nil)
return core.PointerFromQIODevice(core.NewQIODevice())
}
func (ptr *QMediaPlayerControl) ConnectMediaStream(f func() *core.QIODevice) {

69
network/network.cpp
View file

@ -256,6 +256,7 @@ public:
void Signal_HostFound() { callbackQAbstractSocket_HostFound(this); };
bool isSequential() const { return callbackQAbstractSocket_IsSequential(const_cast<MyQAbstractSocket*>(this)) != 0; };
void Signal_ProxyAuthenticationRequired(const QNetworkProxy & proxy, QAuthenticator * authenticator) { callbackQAbstractSocket_ProxyAuthenticationRequired(this, const_cast<QNetworkProxy*>(&proxy), authenticator); };
qint64 readData(char * data, qint64 maxSize) { QtNetwork_PackedString dataPacked = { data, maxSize };return callbackQAbstractSocket_ReadData(this, dataPacked, maxSize); };
qint64 readLineData(char * data, qint64 maxlen) { QtNetwork_PackedString dataPacked = { data, maxlen };return callbackQAbstractSocket_ReadLineData(this, dataPacked, maxlen); };
void resume() { callbackQAbstractSocket_Resume(this); };
void setReadBufferSize(qint64 size) { callbackQAbstractSocket_SetReadBufferSize(this, size); };
@ -526,6 +527,16 @@ long long QAbstractSocket_ReadBufferSize(void* ptr)
return static_cast<QAbstractSocket*>(ptr)->readBufferSize();
}
long long QAbstractSocket_ReadData(void* ptr, char* data, long long maxSize)
{
return static_cast<QAbstractSocket*>(ptr)->readData(data, maxSize);
}
long long QAbstractSocket_ReadDataDefault(void* ptr, char* data, long long maxSize)
{
return static_cast<QAbstractSocket*>(ptr)->QAbstractSocket::readData(data, maxSize);
}
long long QAbstractSocket_ReadLineData(void* ptr, char* data, long long maxlen)
{
return static_cast<QAbstractSocket*>(ptr)->readLineData(data, maxlen);
@ -2045,6 +2056,7 @@ public:
qint64 bytesToWrite() const { return callbackQLocalSocket_BytesToWrite(const_cast<MyQLocalSocket*>(this)); };
bool canReadLine() const { return callbackQLocalSocket_CanReadLine(const_cast<MyQLocalSocket*>(this)) != 0; };
void close() { callbackQLocalSocket_Close(this); };
qint64 readData(char * data, qint64 c) { QtNetwork_PackedString dataPacked = { data, c };return callbackQLocalSocket_ReadData(this, dataPacked, c); };
bool waitForBytesWritten(int msecs) { return callbackQLocalSocket_WaitForBytesWritten(this, msecs) != 0; };
bool waitForReadyRead(int msecs) { return callbackQLocalSocket_WaitForReadyRead(this, msecs) != 0; };
qint64 writeData(const char * data, qint64 c) { QtNetwork_PackedString dataPacked = { const_cast<char*>(data), c };return callbackQLocalSocket_WriteData(this, dataPacked, c); };
@ -2255,6 +2267,16 @@ long long QLocalSocket_ReadBufferSize(void* ptr)
return static_cast<QLocalSocket*>(ptr)->readBufferSize();
}
long long QLocalSocket_ReadData(void* ptr, char* data, long long c)
{
return static_cast<QLocalSocket*>(ptr)->readData(data, c);
}
long long QLocalSocket_ReadDataDefault(void* ptr, char* data, long long c)
{
return static_cast<QLocalSocket*>(ptr)->QLocalSocket::readData(data, c);
}
void QLocalSocket_SetReadBufferSize(void* ptr, long long size)
{
static_cast<QLocalSocket*>(ptr)->setReadBufferSize(size);
@ -4221,6 +4243,7 @@ void QNetworkProxyQuery_DestroyQNetworkProxyQuery(void* ptr)
class MyQNetworkReply: public QNetworkReply
{
public:
MyQNetworkReply(QObject *parent) : QNetworkReply(parent) {};
void setSslConfigurationImplementation(const QSslConfiguration & configuration) { callbackQNetworkReply_SetSslConfigurationImplementation(this, const_cast<QSslConfiguration*>(&configuration)); };
void sslConfigurationImplementation(QSslConfiguration & configuration) const { callbackQNetworkReply_SslConfigurationImplementation(const_cast<MyQNetworkReply*>(this), static_cast<QSslConfiguration*>(&configuration)); };
void abort() { callbackQNetworkReply_Abort(this); };
@ -4242,6 +4265,7 @@ public:
bool isSequential() const { return callbackQNetworkReply_IsSequential(const_cast<MyQNetworkReply*>(this)) != 0; };
bool open(QIODevice::OpenMode mode) { return callbackQNetworkReply_Open(this, mode) != 0; };
qint64 pos() const { return callbackQNetworkReply_Pos(const_cast<MyQNetworkReply*>(this)); };
qint64 readData(char * data, qint64 maxSize) { QtNetwork_PackedString dataPacked = { data, maxSize };return callbackQNetworkReply_ReadData(this, dataPacked, maxSize); };
qint64 readLineData(char * data, qint64 maxSize) { QtNetwork_PackedString dataPacked = { data, maxSize };return callbackQNetworkReply_ReadLineData(this, dataPacked, maxSize); };
bool reset() { return callbackQNetworkReply_Reset(this) != 0; };
bool seek(qint64 pos) { return callbackQNetworkReply_Seek(this, pos) != 0; };
@ -4280,6 +4304,11 @@ void QNetworkReply_SslConfigurationImplementationDefault(void* ptr, void* config
static_cast<QNetworkReply*>(ptr)->QNetworkReply::sslConfigurationImplementation(*static_cast<QSslConfiguration*>(configuration));
}
void* QNetworkReply_NewQNetworkReply(void* parent)
{
return new MyQNetworkReply(static_cast<QObject*>(parent));
}
void QNetworkReply_Abort(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QNetworkReply*>(ptr), "abort");
@ -4630,6 +4659,13 @@ long long QNetworkReply_PosDefault(void* ptr)
return static_cast<QNetworkReply*>(ptr)->QNetworkReply::pos();
}
long long QNetworkReply_ReadData(void* ptr, char* data, long long maxSize)
{
return static_cast<QNetworkReply*>(ptr)->readData(data, maxSize);
}
long long QNetworkReply_ReadLineData(void* ptr, char* data, long long maxSize)
{
return static_cast<QNetworkReply*>(ptr)->readLineData(data, maxSize);
@ -6010,6 +6046,7 @@ public:
void Signal_ModeChanged(QSslSocket::SslMode mode) { callbackQSslSocket_ModeChanged(this, mode); };
void Signal_PeerVerifyError(const QSslError & error) { callbackQSslSocket_PeerVerifyError(this, const_cast<QSslError*>(&error)); };
void Signal_PreSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator * authenticator) { callbackQSslSocket_PreSharedKeyAuthenticationRequired(this, authenticator); };
qint64 readData(char * data, qint64 maxlen) { QtNetwork_PackedString dataPacked = { data, maxlen };return callbackQSslSocket_ReadData(this, dataPacked, maxlen); };
void resume() { callbackQSslSocket_Resume(this); };
void setReadBufferSize(qint64 size) { callbackQSslSocket_SetReadBufferSize(this, size); };
@ -6284,6 +6321,16 @@ long long QSslSocket_Protocol(void* ptr)
return static_cast<QSslSocket*>(ptr)->protocol();
}
long long QSslSocket_ReadData(void* ptr, char* data, long long maxlen)
{
return static_cast<QSslSocket*>(ptr)->readData(data, maxlen);
}
long long QSslSocket_ReadDataDefault(void* ptr, char* data, long long maxlen)
{
return static_cast<QSslSocket*>(ptr)->QSslSocket::readData(data, maxlen);
}
void QSslSocket_Resume(void* ptr)
{
static_cast<QSslSocket*>(ptr)->resume();
@ -6996,6 +7043,7 @@ public:
void connectToHost(const QString & hostName, quint16 port, QIODevice::OpenMode openMode, QAbstractSocket::NetworkLayerProtocol protocol) { QByteArray tcf2288 = hostName.toUtf8(); QtNetwork_PackedString hostNamePacked = { const_cast<char*>(tcf2288.prepend("WHITESPACE").constData()+10), tcf2288.size()-10 };callbackQTcpSocket_ConnectToHost(this, hostNamePacked, port, openMode, protocol); };
void disconnectFromHost() { callbackQTcpSocket_DisconnectFromHost(this); };
bool isSequential() const { return callbackQTcpSocket_IsSequential(const_cast<MyQTcpSocket*>(this)) != 0; };
qint64 readData(char * data, qint64 maxSize) { QtNetwork_PackedString dataPacked = { data, maxSize };return callbackQTcpSocket_ReadData(this, dataPacked, maxSize); };
qint64 readLineData(char * data, qint64 maxlen) { QtNetwork_PackedString dataPacked = { data, maxlen };return callbackQTcpSocket_ReadLineData(this, dataPacked, maxlen); };
void resume() { callbackQTcpSocket_Resume(this); };
void setReadBufferSize(qint64 size) { callbackQTcpSocket_SetReadBufferSize(this, size); };
@ -7129,6 +7177,16 @@ char QTcpSocket_IsSequentialDefault(void* ptr)
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::isSequential();
}
long long QTcpSocket_ReadData(void* ptr, char* data, long long maxSize)
{
return static_cast<QTcpSocket*>(ptr)->readData(data, maxSize);
}
long long QTcpSocket_ReadDataDefault(void* ptr, char* data, long long maxSize)
{
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::readData(data, maxSize);
}
long long QTcpSocket_ReadLineData(void* ptr, char* data, long long maxlen)
{
return static_cast<QTcpSocket*>(ptr)->readLineData(data, maxlen);
@ -7391,6 +7449,7 @@ public:
void connectToHost(const QString & hostName, quint16 port, QIODevice::OpenMode openMode, QAbstractSocket::NetworkLayerProtocol protocol) { QByteArray tcf2288 = hostName.toUtf8(); QtNetwork_PackedString hostNamePacked = { const_cast<char*>(tcf2288.prepend("WHITESPACE").constData()+10), tcf2288.size()-10 };callbackQUdpSocket_ConnectToHost(this, hostNamePacked, port, openMode, protocol); };
void disconnectFromHost() { callbackQUdpSocket_DisconnectFromHost(this); };
bool isSequential() const { return callbackQUdpSocket_IsSequential(const_cast<MyQUdpSocket*>(this)) != 0; };
qint64 readData(char * data, qint64 maxSize) { QtNetwork_PackedString dataPacked = { data, maxSize };return callbackQUdpSocket_ReadData(this, dataPacked, maxSize); };
qint64 readLineData(char * data, qint64 maxlen) { QtNetwork_PackedString dataPacked = { data, maxlen };return callbackQUdpSocket_ReadLineData(this, dataPacked, maxlen); };
void resume() { callbackQUdpSocket_Resume(this); };
void setReadBufferSize(qint64 size) { callbackQUdpSocket_SetReadBufferSize(this, size); };
@ -7579,6 +7638,16 @@ char QUdpSocket_IsSequentialDefault(void* ptr)
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::isSequential();
}
long long QUdpSocket_ReadData(void* ptr, char* data, long long maxSize)
{
return static_cast<QUdpSocket*>(ptr)->readData(data, maxSize);
}
long long QUdpSocket_ReadDataDefault(void* ptr, char* data, long long maxSize)
{
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::readData(data, maxSize);
}
long long QUdpSocket_ReadLineData(void* ptr, char* data, long long maxlen)
{
return static_cast<QUdpSocket*>(ptr)->readLineData(data, maxlen);

350
network/network.go
View file

@ -4,6 +4,7 @@ package network
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "network.h"
import "C"
import (
@ -134,7 +135,7 @@ func callbackQAbstractNetworkCache_Data(ptr unsafe.Pointer, url unsafe.Pointer)
return core.PointerFromQIODevice(signal.(func(*core.QUrl) *core.QIODevice)(core.NewQUrlFromPointer(url)))
}
return core.PointerFromQIODevice(nil)
return core.PointerFromQIODevice(core.NewQIODevice())
}
func (ptr *QAbstractNetworkCache) ConnectData(f func(url *core.QUrl) *core.QIODevice) {
@ -231,7 +232,7 @@ func callbackQAbstractNetworkCache_Prepare(ptr unsafe.Pointer, metaData unsafe.P
return core.PointerFromQIODevice(signal.(func(*QNetworkCacheMetaData) *core.QIODevice)(NewQNetworkCacheMetaDataFromPointer(metaData)))
}
return core.PointerFromQIODevice(nil)
return core.PointerFromQIODevice(core.NewQIODevice())
}
func (ptr *QAbstractNetworkCache) ConnectPrepare(f func(metaData *QNetworkCacheMetaData) *core.QIODevice) {
@ -1424,6 +1425,65 @@ func (ptr *QAbstractSocket) ReadBufferSize() int64 {
return 0
}
//export callbackQAbstractSocket_ReadData
func callbackQAbstractSocket_ReadData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxSize C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QAbstractSocket::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(maxSize)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
var retS = cGoUnpackString(data)
var ret = C.longlong(NewQAbstractSocketFromPointer(ptr).ReadDataDefault(&retS, int64(maxSize)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
func (ptr *QAbstractSocket) ConnectReadData(f func(data *string, maxSize int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QAbstractSocket::readData", f)
}
}
func (ptr *QAbstractSocket) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QAbstractSocket::readData")
}
}
func (ptr *QAbstractSocket) ReadData(data *string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxSize)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QAbstractSocket_ReadData(ptr.Pointer(), dataC, C.longlong(maxSize)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QAbstractSocket) ReadDataDefault(data *string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxSize)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QAbstractSocket_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(maxSize)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
//export callbackQAbstractSocket_ReadLineData
func callbackQAbstractSocket_ReadLineData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxlen C.longlong) C.longlong {
@ -5986,6 +6046,65 @@ func (ptr *QLocalSocket) ReadBufferSize() int64 {
return 0
}
//export callbackQLocalSocket_ReadData
func callbackQLocalSocket_ReadData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, c C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QLocalSocket::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(c)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
var retS = cGoUnpackString(data)
var ret = C.longlong(NewQLocalSocketFromPointer(ptr).ReadDataDefault(&retS, int64(c)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
func (ptr *QLocalSocket) ConnectReadData(f func(data *string, c int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QLocalSocket::readData", f)
}
}
func (ptr *QLocalSocket) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QLocalSocket::readData")
}
}
func (ptr *QLocalSocket) ReadData(data *string, c int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(c)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QLocalSocket_ReadData(ptr.Pointer(), dataC, C.longlong(c)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QLocalSocket) ReadDataDefault(data *string, c int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(c)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QLocalSocket_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(c)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QLocalSocket) SetReadBufferSize(size int64) {
if ptr.Pointer() != nil {
C.QLocalSocket_SetReadBufferSize(ptr.Pointer(), C.longlong(size))
@ -11410,6 +11529,14 @@ func (ptr *QNetworkReply) SslConfigurationImplementationDefault(configuration QS
}
}
func NewQNetworkReply(parent core.QObject_ITF) *QNetworkReply {
var tmpValue = NewQNetworkReplyFromPointer(C.QNetworkReply_NewQNetworkReply(core.PointerFromQObject(parent)))
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
}
return tmpValue
}
//export callbackQNetworkReply_Abort
func callbackQNetworkReply_Abort(ptr unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QNetworkReply::abort"); signal != nil {
@ -12236,6 +12363,48 @@ func (ptr *QNetworkReply) PosDefault() int64 {
return 0
}
//export callbackQNetworkReply_ReadData
func callbackQNetworkReply_ReadData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxSize C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QNetworkReply::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(maxSize)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
return C.longlong(0)
}
func (ptr *QNetworkReply) ConnectReadData(f func(data *string, maxSize int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QNetworkReply::readData", f)
}
}
func (ptr *QNetworkReply) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QNetworkReply::readData")
}
}
func (ptr *QNetworkReply) ReadData(data *string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxSize)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QNetworkReply_ReadData(ptr.Pointer(), dataC, C.longlong(maxSize)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
//export callbackQNetworkReply_ReadLineData
func callbackQNetworkReply_ReadLineData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxSize C.longlong) C.longlong {
@ -16335,6 +16504,65 @@ func (ptr *QSslSocket) Protocol() QSsl__SslProtocol {
return 0
}
//export callbackQSslSocket_ReadData
func callbackQSslSocket_ReadData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxlen C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSslSocket::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(maxlen)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
var retS = cGoUnpackString(data)
var ret = C.longlong(NewQSslSocketFromPointer(ptr).ReadDataDefault(&retS, int64(maxlen)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
func (ptr *QSslSocket) ConnectReadData(f func(data *string, maxlen int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSslSocket::readData", f)
}
}
func (ptr *QSslSocket) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSslSocket::readData")
}
}
func (ptr *QSslSocket) ReadData(data *string, maxlen int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxlen)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QSslSocket_ReadData(ptr.Pointer(), dataC, C.longlong(maxlen)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QSslSocket) ReadDataDefault(data *string, maxlen int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxlen)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QSslSocket_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(maxlen)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
//export callbackQSslSocket_Resume
func callbackQSslSocket_Resume(ptr unsafe.Pointer) {
@ -18793,6 +19021,65 @@ func (ptr *QTcpSocket) IsSequentialDefault() bool {
return false
}
//export callbackQTcpSocket_ReadData
func callbackQTcpSocket_ReadData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxSize C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QTcpSocket::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(maxSize)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
var retS = cGoUnpackString(data)
var ret = C.longlong(NewQTcpSocketFromPointer(ptr).ReadDataDefault(&retS, int64(maxSize)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
func (ptr *QTcpSocket) ConnectReadData(f func(data *string, maxSize int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::readData", f)
}
}
func (ptr *QTcpSocket) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::readData")
}
}
func (ptr *QTcpSocket) ReadData(data *string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxSize)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QTcpSocket_ReadData(ptr.Pointer(), dataC, C.longlong(maxSize)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QTcpSocket) ReadDataDefault(data *string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxSize)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QTcpSocket_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(maxSize)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
//export callbackQTcpSocket_ReadLineData
func callbackQTcpSocket_ReadLineData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxlen C.longlong) C.longlong {
@ -20222,6 +20509,65 @@ func (ptr *QUdpSocket) IsSequentialDefault() bool {
return false
}
//export callbackQUdpSocket_ReadData
func callbackQUdpSocket_ReadData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxSize C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QUdpSocket::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(maxSize)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
var retS = cGoUnpackString(data)
var ret = C.longlong(NewQUdpSocketFromPointer(ptr).ReadDataDefault(&retS, int64(maxSize)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
func (ptr *QUdpSocket) ConnectReadData(f func(data *string, maxSize int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::readData", f)
}
}
func (ptr *QUdpSocket) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::readData")
}
}
func (ptr *QUdpSocket) ReadData(data *string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxSize)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QUdpSocket_ReadData(ptr.Pointer(), dataC, C.longlong(maxSize)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QUdpSocket) ReadDataDefault(data *string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxSize)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QUdpSocket_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(maxSize)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
//export callbackQUdpSocket_ReadLineData
func callbackQUdpSocket_ReadLineData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxlen C.longlong) C.longlong {

13
network/network.h
View file

@ -90,6 +90,8 @@ void QAbstractSocket_ConnectProxyAuthenticationRequired(void* ptr);
void QAbstractSocket_DisconnectProxyAuthenticationRequired(void* ptr);
void QAbstractSocket_ProxyAuthenticationRequired(void* ptr, void* proxy, void* authenticator);
long long QAbstractSocket_ReadBufferSize(void* ptr);
long long QAbstractSocket_ReadData(void* ptr, char* data, long long maxSize);
long long QAbstractSocket_ReadDataDefault(void* ptr, char* data, long long maxSize);
long long QAbstractSocket_ReadLineData(void* ptr, char* data, long long maxlen);
long long QAbstractSocket_ReadLineDataDefault(void* ptr, char* data, long long maxlen);
void QAbstractSocket_Resume(void* ptr);
@ -423,6 +425,8 @@ long long QLocalSocket_Error(void* ptr);
char QLocalSocket_Flush(void* ptr);
char QLocalSocket_IsValid(void* ptr);
long long QLocalSocket_ReadBufferSize(void* ptr);
long long QLocalSocket_ReadData(void* ptr, char* data, long long c);
long long QLocalSocket_ReadDataDefault(void* ptr, char* data, long long c);
void QLocalSocket_SetReadBufferSize(void* ptr, long long size);
char QLocalSocket_WaitForBytesWritten(void* ptr, int msecs);
char QLocalSocket_WaitForBytesWrittenDefault(void* ptr, int msecs);
@ -800,6 +804,7 @@ void QNetworkReply_SetSslConfigurationImplementation(void* ptr, void* configurat
void QNetworkReply_SetSslConfigurationImplementationDefault(void* ptr, void* configuration);
void QNetworkReply_SslConfigurationImplementation(void* ptr, void* configuration);
void QNetworkReply_SslConfigurationImplementationDefault(void* ptr, void* configuration);
void* QNetworkReply_NewQNetworkReply(void* parent);
void QNetworkReply_Abort(void* ptr);
void* QNetworkReply_Attribute(void* ptr, long long code);
void QNetworkReply_Close(void* ptr);
@ -870,6 +875,8 @@ char QNetworkReply_Open(void* ptr, long long mode);
char QNetworkReply_OpenDefault(void* ptr, long long mode);
long long QNetworkReply_Pos(void* ptr);
long long QNetworkReply_PosDefault(void* ptr);
long long QNetworkReply_ReadData(void* ptr, char* data, long long maxSize);
;
long long QNetworkReply_ReadLineData(void* ptr, char* data, long long maxSize);
long long QNetworkReply_ReadLineDataDefault(void* ptr, char* data, long long maxSize);
char QNetworkReply_Reset(void* ptr);
@ -1185,6 +1192,8 @@ void QSslSocket_DisconnectPreSharedKeyAuthenticationRequired(void* ptr);
void QSslSocket_PreSharedKeyAuthenticationRequired(void* ptr, void* authenticator);
void* QSslSocket_PrivateKey(void* ptr);
long long QSslSocket_Protocol(void* ptr);
long long QSslSocket_ReadData(void* ptr, char* data, long long maxlen);
long long QSslSocket_ReadDataDefault(void* ptr, char* data, long long maxlen);
void QSslSocket_Resume(void* ptr);
void QSslSocket_ResumeDefault(void* ptr);
void* QSslSocket_SessionCipher(void* ptr);
@ -1345,6 +1354,8 @@ void QTcpSocket_DisconnectFromHost(void* ptr);
void QTcpSocket_DisconnectFromHostDefault(void* ptr);
char QTcpSocket_IsSequential(void* ptr);
char QTcpSocket_IsSequentialDefault(void* ptr);
long long QTcpSocket_ReadData(void* ptr, char* data, long long maxSize);
long long QTcpSocket_ReadDataDefault(void* ptr, char* data, long long maxSize);
long long QTcpSocket_ReadLineData(void* ptr, char* data, long long maxlen);
long long QTcpSocket_ReadLineDataDefault(void* ptr, char* data, long long maxlen);
void QTcpSocket_Resume(void* ptr);
@ -1429,6 +1440,8 @@ void QUdpSocket_DisconnectFromHost(void* ptr);
void QUdpSocket_DisconnectFromHostDefault(void* ptr);
char QUdpSocket_IsSequential(void* ptr);
char QUdpSocket_IsSequentialDefault(void* ptr);
long long QUdpSocket_ReadData(void* ptr, char* data, long long maxSize);
long long QUdpSocket_ReadDataDefault(void* ptr, char* data, long long maxSize);
long long QUdpSocket_ReadLineData(void* ptr, char* data, long long maxlen);
long long QUdpSocket_ReadLineDataDefault(void* ptr, char* data, long long maxlen);
void QUdpSocket_Resume(void* ptr);

1
nfc/nfc.go
View file

@ -4,6 +4,7 @@ package nfc
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "nfc.h"
import "C"
import (

1
positioning/positioning.go
View file

@ -4,6 +4,7 @@ package positioning
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "positioning.h"
import "C"
import (

1
printsupport/printsupport.go
View file

@ -4,6 +4,7 @@ package printsupport
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "printsupport.h"
import "C"
import (

1
purchasing/purchasing.go
View file

@ -4,6 +4,7 @@ package purchasing
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "purchasing.h"
import "C"
import (

1
qml/qml.go
View file

@ -4,6 +4,7 @@ package qml
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "qml.h"
import "C"
import (

1
quick/quick.go
View file

@ -4,6 +4,7 @@ package quick
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "quick.h"
import "C"
import (

1
quickcontrols2/quickcontrols2.go
View file

@ -4,6 +4,7 @@ package quickcontrols2
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "quickcontrols2.h"
import "C"
import (

1
sailfish/sailfish.go
View file

@ -4,6 +4,7 @@ package sailfish
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "sailfish_sailfish.h"
import "C"
import (

1
sailfish/sailfish_sailfish.go
View file

@ -4,6 +4,7 @@ package sailfish
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "sailfish_sailfish.h"
import "C"
import (

1
script/script.go
View file

@ -4,6 +4,7 @@ package script
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "script.h"
import "C"
import (

1
scripttools/scripttools.go
View file

@ -4,6 +4,7 @@ package scripttools
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "scripttools.h"
import "C"
import (

1
scxml/scxml.go
View file

@ -4,6 +4,7 @@ package scxml
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "scxml.h"
import "C"
import (

1
sensors/sensors.go
View file

@ -4,6 +4,7 @@ package sensors
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "sensors.h"
import "C"
import (

31
serialbus/serialbus.cpp
View file

@ -1616,6 +1616,16 @@ char QModbusRtuSerialSlave_ProcessesBroadcastDefault(void* ptr)
return static_cast<QModbusRtuSerialSlave*>(ptr)->QModbusRtuSerialSlave::processesBroadcast();
}
char QModbusRtuSerialSlave_ReadData(void* ptr, void* newData)
{
return static_cast<QModbusRtuSerialSlave*>(ptr)->readData(static_cast<QModbusDataUnit*>(newData));
}
char QModbusRtuSerialSlave_ReadDataDefault(void* ptr, void* newData)
{
return static_cast<QModbusRtuSerialSlave*>(ptr)->QModbusRtuSerialSlave::readData(static_cast<QModbusDataUnit*>(newData));
}
@ -1768,6 +1778,7 @@ public:
QModbusResponse processPrivateRequest(const QModbusPdu & request) { return *static_cast<QModbusResponse*>(callbackQModbusServer_ProcessPrivateRequest(this, const_cast<QModbusPdu*>(&request))); };
QModbusResponse processRequest(const QModbusPdu & request) { return *static_cast<QModbusResponse*>(callbackQModbusServer_ProcessRequest(this, const_cast<QModbusPdu*>(&request))); };
bool processesBroadcast() const { return callbackQModbusServer_ProcessesBroadcast(const_cast<MyQModbusServer*>(this)) != 0; };
bool readData(QModbusDataUnit * newData) const { return callbackQModbusServer_ReadData(const_cast<MyQModbusServer*>(this), newData) != 0; };
bool setValue(int option, const QVariant & newValue) { return callbackQModbusServer_SetValue(this, option, const_cast<QVariant*>(&newValue)) != 0; };
QVariant value(int option) const { return *static_cast<QVariant*>(callbackQModbusServer_Value(const_cast<MyQModbusServer*>(this), option)); };
@ -1845,6 +1856,16 @@ char QModbusServer_ProcessesBroadcastDefault(void* ptr)
return static_cast<QModbusServer*>(ptr)->QModbusServer::processesBroadcast();
}
char QModbusServer_ReadData(void* ptr, void* newData)
{
return static_cast<QModbusServer*>(ptr)->readData(static_cast<QModbusDataUnit*>(newData));
}
char QModbusServer_ReadDataDefault(void* ptr, void* newData)
{
return static_cast<QModbusServer*>(ptr)->QModbusServer::readData(static_cast<QModbusDataUnit*>(newData));
}
int QModbusServer_ServerAddress(void* ptr)
{
return static_cast<QModbusServer*>(ptr)->serverAddress();
@ -2183,6 +2204,16 @@ char QModbusTcpServer_ProcessesBroadcastDefault(void* ptr)
return static_cast<QModbusTcpServer*>(ptr)->QModbusTcpServer::processesBroadcast();
}
char QModbusTcpServer_ReadData(void* ptr, void* newData)
{
return static_cast<QModbusTcpServer*>(ptr)->readData(static_cast<QModbusDataUnit*>(newData));
}
char QModbusTcpServer_ReadDataDefault(void* ptr, void* newData)
{
return static_cast<QModbusTcpServer*>(ptr)->QModbusTcpServer::readData(static_cast<QModbusDataUnit*>(newData));
}

115
serialbus/serialbus.go
View file

@ -4,6 +4,7 @@ package serialbus
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "serialbus.h"
import "C"
import (
@ -4891,6 +4892,44 @@ func (ptr *QModbusRtuSerialSlave) ProcessesBroadcastDefault() bool {
return false
}
//export callbackQModbusRtuSerialSlave_ReadData
func callbackQModbusRtuSerialSlave_ReadData(ptr unsafe.Pointer, newData unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QModbusRtuSerialSlave::readData"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*QModbusDataUnit) bool)(NewQModbusDataUnitFromPointer(newData)))))
}
return C.char(int8(qt.GoBoolToInt(NewQModbusRtuSerialSlaveFromPointer(ptr).ReadDataDefault(NewQModbusDataUnitFromPointer(newData)))))
}
func (ptr *QModbusRtuSerialSlave) ConnectReadData(f func(newData *QModbusDataUnit) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QModbusRtuSerialSlave::readData", f)
}
}
func (ptr *QModbusRtuSerialSlave) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QModbusRtuSerialSlave::readData")
}
}
func (ptr *QModbusRtuSerialSlave) ReadData(newData QModbusDataUnit_ITF) bool {
if ptr.Pointer() != nil {
return C.QModbusRtuSerialSlave_ReadData(ptr.Pointer(), PointerFromQModbusDataUnit(newData)) != 0
}
return false
}
func (ptr *QModbusRtuSerialSlave) ReadDataDefault(newData QModbusDataUnit_ITF) bool {
if ptr.Pointer() != nil {
return C.QModbusRtuSerialSlave_ReadDataDefault(ptr.Pointer(), PointerFromQModbusDataUnit(newData)) != 0
}
return false
}
func (ptr *QModbusRtuSerialSlave) DisconnectSetMap() {
if ptr.Pointer() != nil {
@ -5658,6 +5697,44 @@ func (ptr *QModbusServer) ProcessesBroadcastDefault() bool {
return false
}
//export callbackQModbusServer_ReadData
func callbackQModbusServer_ReadData(ptr unsafe.Pointer, newData unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QModbusServer::readData"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*QModbusDataUnit) bool)(NewQModbusDataUnitFromPointer(newData)))))
}
return C.char(int8(qt.GoBoolToInt(NewQModbusServerFromPointer(ptr).ReadDataDefault(NewQModbusDataUnitFromPointer(newData)))))
}
func (ptr *QModbusServer) ConnectReadData(f func(newData *QModbusDataUnit) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QModbusServer::readData", f)
}
}
func (ptr *QModbusServer) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QModbusServer::readData")
}
}
func (ptr *QModbusServer) ReadData(newData QModbusDataUnit_ITF) bool {
if ptr.Pointer() != nil {
return C.QModbusServer_ReadData(ptr.Pointer(), PointerFromQModbusDataUnit(newData)) != 0
}
return false
}
func (ptr *QModbusServer) ReadDataDefault(newData QModbusDataUnit_ITF) bool {
if ptr.Pointer() != nil {
return C.QModbusServer_ReadDataDefault(ptr.Pointer(), PointerFromQModbusDataUnit(newData)) != 0
}
return false
}
func (ptr *QModbusServer) ServerAddress() int {
if ptr.Pointer() != nil {
return int(int32(C.QModbusServer_ServerAddress(ptr.Pointer())))
@ -6917,6 +6994,44 @@ func (ptr *QModbusTcpServer) ProcessesBroadcastDefault() bool {
return false
}
//export callbackQModbusTcpServer_ReadData
func callbackQModbusTcpServer_ReadData(ptr unsafe.Pointer, newData unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QModbusTcpServer::readData"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*QModbusDataUnit) bool)(NewQModbusDataUnitFromPointer(newData)))))
}
return C.char(int8(qt.GoBoolToInt(NewQModbusTcpServerFromPointer(ptr).ReadDataDefault(NewQModbusDataUnitFromPointer(newData)))))
}
func (ptr *QModbusTcpServer) ConnectReadData(f func(newData *QModbusDataUnit) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QModbusTcpServer::readData", f)
}
}
func (ptr *QModbusTcpServer) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QModbusTcpServer::readData")
}
}
func (ptr *QModbusTcpServer) ReadData(newData QModbusDataUnit_ITF) bool {
if ptr.Pointer() != nil {
return C.QModbusTcpServer_ReadData(ptr.Pointer(), PointerFromQModbusDataUnit(newData)) != 0
}
return false
}
func (ptr *QModbusTcpServer) ReadDataDefault(newData QModbusDataUnit_ITF) bool {
if ptr.Pointer() != nil {
return C.QModbusTcpServer_ReadDataDefault(ptr.Pointer(), PointerFromQModbusDataUnit(newData)) != 0
}
return false
}
func (ptr *QModbusTcpServer) DisconnectSetMap() {
if ptr.Pointer() != nil {

6
serialbus/serialbus.h
View file

@ -309,6 +309,8 @@ void* QModbusRtuSerialSlave_ProcessRequest(void* ptr, void* request);
void* QModbusRtuSerialSlave_ProcessRequestDefault(void* ptr, void* request);
char QModbusRtuSerialSlave_ProcessesBroadcast(void* ptr);
char QModbusRtuSerialSlave_ProcessesBroadcastDefault(void* ptr);
char QModbusRtuSerialSlave_ReadData(void* ptr, void* newData);
char QModbusRtuSerialSlave_ReadDataDefault(void* ptr, void* newData);
;
;
char QModbusRtuSerialSlave_SetValue(void* ptr, int option, void* newValue);
@ -351,6 +353,8 @@ void* QModbusServer_ProcessRequest(void* ptr, void* request);
void* QModbusServer_ProcessRequestDefault(void* ptr, void* request);
char QModbusServer_ProcessesBroadcast(void* ptr);
char QModbusServer_ProcessesBroadcastDefault(void* ptr);
char QModbusServer_ReadData(void* ptr, void* newData);
char QModbusServer_ReadDataDefault(void* ptr, void* newData);
int QModbusServer_ServerAddress(void* ptr);
char QModbusServer_SetData2(void* ptr, long long table, unsigned short address, unsigned short data);
char QModbusServer_SetData(void* ptr, void* newData);
@ -421,6 +425,8 @@ void* QModbusTcpServer_ProcessRequest(void* ptr, void* request);
void* QModbusTcpServer_ProcessRequestDefault(void* ptr, void* request);
char QModbusTcpServer_ProcessesBroadcast(void* ptr);
char QModbusTcpServer_ProcessesBroadcastDefault(void* ptr);
char QModbusTcpServer_ReadData(void* ptr, void* newData);
char QModbusTcpServer_ReadDataDefault(void* ptr, void* newData);
;
;
char QModbusTcpServer_SetValue(void* ptr, int option, void* newValue);

11
serialport/serialport.cpp
View file

@ -40,6 +40,7 @@ public:
void Signal_FlowControlChanged(QSerialPort::FlowControl flow) { callbackQSerialPort_FlowControlChanged(this, flow); };
bool isSequential() const { return callbackQSerialPort_IsSequential(const_cast<MyQSerialPort*>(this)) != 0; };
void Signal_ParityChanged(QSerialPort::Parity parity) { callbackQSerialPort_ParityChanged(this, parity); };
qint64 readData(char * data, qint64 maxSize) { QtSerialPort_PackedString dataPacked = { data, maxSize };return callbackQSerialPort_ReadData(this, dataPacked, maxSize); };
qint64 readLineData(char * data, qint64 maxSize) { QtSerialPort_PackedString dataPacked = { data, maxSize };return callbackQSerialPort_ReadLineData(this, dataPacked, maxSize); };
void Signal_RequestToSendChanged(bool set) { callbackQSerialPort_RequestToSendChanged(this, set); };
void Signal_StopBitsChanged(QSerialPort::StopBits stopBits) { callbackQSerialPort_StopBitsChanged(this, stopBits); };
@ -362,6 +363,16 @@ long long QSerialPort_ReadBufferSize(void* ptr)
return static_cast<QSerialPort*>(ptr)->readBufferSize();
}
long long QSerialPort_ReadData(void* ptr, char* data, long long maxSize)
{
return static_cast<QSerialPort*>(ptr)->readData(data, maxSize);
}
long long QSerialPort_ReadDataDefault(void* ptr, char* data, long long maxSize)
{
return static_cast<QSerialPort*>(ptr)->QSerialPort::readData(data, maxSize);
}
long long QSerialPort_ReadLineData(void* ptr, char* data, long long maxSize)
{
return static_cast<QSerialPort*>(ptr)->readLineData(data, maxSize);

61
serialport/serialport.go
View file

@ -4,6 +4,7 @@ package serialport
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "serialport.h"
import "C"
import (
@ -11,6 +12,7 @@ import (
"github.com/therecipe/qt"
"github.com/therecipe/qt/core"
"runtime"
"strings"
"unsafe"
)
@ -793,6 +795,65 @@ func (ptr *QSerialPort) ReadBufferSize() int64 {
return 0
}
//export callbackQSerialPort_ReadData
func callbackQSerialPort_ReadData(ptr unsafe.Pointer, data C.struct_QtSerialPort_PackedString, maxSize C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSerialPort::readData"); signal != nil {
var retS = cGoUnpackString(data)
var ret = C.longlong(signal.(func(*string, int64) int64)(&retS, int64(maxSize)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
var retS = cGoUnpackString(data)
var ret = C.longlong(NewQSerialPortFromPointer(ptr).ReadDataDefault(&retS, int64(maxSize)))
if ret > 0 {
C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer(C.CString(retS)), C.size_t(ret))
}
return ret
}
func (ptr *QSerialPort) ConnectReadData(f func(data *string, maxSize int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSerialPort::readData", f)
}
}
func (ptr *QSerialPort) DisconnectReadData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSerialPort::readData")
}
}
func (ptr *QSerialPort) ReadData(data *string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxSize)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QSerialPort_ReadData(ptr.Pointer(), dataC, C.longlong(maxSize)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
func (ptr *QSerialPort) ReadDataDefault(data *string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(strings.Repeat("0", int(maxSize)))
defer C.free(unsafe.Pointer(dataC))
var ret = int64(C.QSerialPort_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(maxSize)))
if ret > 0 {
*data = C.GoStringN(dataC, C.int(ret))
}
return ret
}
return 0
}
//export callbackQSerialPort_ReadLineData
func callbackQSerialPort_ReadLineData(ptr unsafe.Pointer, data C.struct_QtSerialPort_PackedString, maxSize C.longlong) C.longlong {

2
serialport/serialport.h
View file

@ -73,6 +73,8 @@ void QSerialPort_ParityChanged(void* ptr, long long parity);
long long QSerialPort_PinoutSignals(void* ptr);
struct QtSerialPort_PackedString QSerialPort_PortName(void* ptr);
long long QSerialPort_ReadBufferSize(void* ptr);
long long QSerialPort_ReadData(void* ptr, char* data, long long maxSize);
long long QSerialPort_ReadDataDefault(void* ptr, char* data, long long maxSize);
long long QSerialPort_ReadLineData(void* ptr, char* data, long long maxSize);
long long QSerialPort_ReadLineDataDefault(void* ptr, char* data, long long maxSize);
void QSerialPort_ConnectRequestToSendChanged(void* ptr);

1
sql/sql.go
View file

@ -4,6 +4,7 @@ package sql
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "sql.h"
import "C"
import (

1
svg/svg.go
View file

@ -4,6 +4,7 @@ package svg
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "svg.h"
import "C"
import (

1
testlib/testlib.go
View file

@ -4,6 +4,7 @@ package testlib
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "testlib.h"
import "C"
import (

1
uitools/uitools.go
View file

@ -4,6 +4,7 @@ package uitools
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "uitools.h"
import "C"
import (

1
webchannel/webchannel.go
View file

@ -4,6 +4,7 @@ package webchannel
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "webchannel.h"
import "C"
import (

1
webengine/webengine.go
View file

@ -4,6 +4,7 @@ package webengine
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "webengine.h"
import "C"
import (

1
websockets/websockets.go
View file

@ -4,6 +4,7 @@ package websockets
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "websockets.h"
import "C"
import (

1
widgets/widgets.go
View file

@ -4,6 +4,7 @@ package widgets
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "widgets.h"
import "C"
import (

1
xml/xml.go
View file

@ -4,6 +4,7 @@ package xml
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "xml.h"
import "C"
import (

1
xmlpatterns/xmlpatterns.go
View file

@ -4,6 +4,7 @@ package xmlpatterns
//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "xmlpatterns.h"
import "C"
import (