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

complete rewrite

Browse source
This commit is contained in:
therecipe 2015-10-24 17:18:24 +02:00
parent 017a32d023
commit 1eb57fbb81
4765 changed files with 273798 additions and 41007 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

0
LICENSE Normal file → Executable file
View file

82
README.md Normal file → Executable file
View file

@ -1,75 +1,65 @@
#Qt binding for Go
#Qt binding for Go (Windows / Mac OS X / Linux / Android)
##Windows (x86):
##Windows (x86)
(currently not working) -> https://support.microsoft.com/kb/830473
1. Install Go >= 1.4 (x86)
> https://golang.org/dl/
1. Install Go >= 1.5.1
> https://storage.googleapis.com/golang/go1.5.1.windows-386.msi
2. Install Qt 5.4.0
> https://download.qt-project.org/official_releases/qt/5.4/5.4.0/qt-opensource-windows-x86-mingw491_opengl-5.4.0.exe
2. Install Qt 5.5.1 ("C:\Qt\Qt5.5.1")
> https://download.qt.io/official_releases/qt/5.5/5.5.1/qt-opensource-windows-x86-android-5.5.1.exe
3. Add the directory that contains "gcc" to your PATH
> C:\Qt\Qt5.4.0\Tools\mingw491_32\bin
> C:\Qt\Qt5.5.1\Tools\mingw492_32\bin
4. Download the qt binding
> go get -d github.com/therecipe/qt
> go get github.com/therecipe/qt
5. Setup your build environment (edit the file if necessary)
> cgo_windows_386.go
5. Generate, install and test
> github.com/therecipe/qt/internal/binding/make.sh
6. Install the qt binding (failed ? -> go back to 5)
> go install github.com/therecipe/qt
##Mac OS X (x64)
7. Test the example (edit the file if necessary)
> example/windows/deploy_windows.bat
1. Install Go >= 1.5.1
> https://storage.googleapis.com/golang/go1.5.1.darwin-amd64.pkg
##Mac OS X (x64):
2. Install Qt 5.5.1 ("/usr/local/Qt5.5.1")
> https://download.qt.io/official_releases/qt/5.5/5.5.1/qt-opensource-mac-x64-android-5.5.1.dmg
1. Install Go >= 1.4
> https://golang.org/dl/
2. Install Qt 5.4.0
> https://download.qt-project.org/official_releases/qt/5.4/5.4.0/qt-opensource-mac-x64-clang-5.4.0.dmg
3. Install Xcode >= 6.1
3. Install Xcode >= 7.0.1
4. Download the qt binding
> go get -d github.com/therecipe/qt
> go get github.com/therecipe/qt
5. Setup your build environment (edit the file if necessary)
> cgo_darwin_amd64.go
5. Generate, install and test
> github.com/therecipe/qt/internal/binding/make.sh
6. Install the qt binding (failed ? -> go back to 5)
> go install github.com/therecipe/qt
##Linux (x86/x64)
7. Test the example (edit the file if necessary)
> example/mac/deploy_mac.sh
1. Install Go >= 1.5.1
##Linux (x86/x64):
>(x86) https://storage.googleapis.com/golang/go1.5.1.linux-386.tar.gz
1. Install Go >= 1.4 (x86/x64)
> https://golang.org/dl/
>(x64) https://storage.googleapis.com/golang/go1.5.1.linux-amd64.tar.gz
2. Install Qt 5.4.0
2. Install Qt 5.5.1 ("/usr/local/Qt5.5.1")
>(x86) https://download.qt.io/official_releases/qt/5.5/5.5.1/qt-opensource-linux-x86-android-5.5.1.run
>(x64) https://download.qt.io/official_releases/qt/5.5/5.5.1/qt-opensource-linux-x64-android-5.5.1.run
>(x86) https://download.qt-project.org/official_releases/qt/5.4/5.4.0/qt-opensource-linux-x86-5.4.0.run
>(x64) https://download.qt-project.org/official_releases/qt/5.4/5.4.0/qt-opensource-linux-x64-5.4.0.run
3. Install "g++"
> sudo apt-get install build-essential
> sudo apt-get install g++
4. Install OpenGL libraries
4. Install OpenGL dependencies
> sudo apt-get install mesa-common-dev
5. Download the qt binding
> go get -d github.com/therecipe/qt
> go get github.com/therecipe/qt
6. Setup your build environment (edit the file if necessary)
> cgo_linux_*.go
6. Generate, install and test
> github.com/therecipe/qt/internal/binding/make.bat
7. Install the qt binding (failed ? -> go back to 6)
> go install github.com/therecipe/qt
##Android (armv7)
8. Test the example (edit the file if necessary)
> example/linux/deploy_linux_*.sh
TBA

13
bluetooth/cgo_darwin_amd64.go Executable file
View file

@ -0,0 +1,13 @@
package bluetooth
/*
#cgo CPPFLAGS: -pipe -O2 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk -mmacosx-version-min=10.7 -Wall -W
#cgo CPPFLAGS: -DQT_NO_DEBUG -DQT_CORE_LIB -DQT_CONCURRENT_LIB -DQT_BLUETOOTH_LIB
#cgo CPPFLAGS: -I/usr/local/Qt5.5.1/5.5/clang_64/mkspecs/macx-clang -F/usr/local/Qt5.5.1/5.5/clang_64/lib
#cgo CPPFLAGS: -I/usr/local/Qt5.5.1/5.5/clang_64/lib/QtCore.framework/Headers -I/usr/local/Qt5.5.1/5.5/clang_64/lib/QtConcurrent.framework/Headers -I/usr/local/Qt5.5.1/5.5/clang_64/lib/QtBluetooth.framework/Headers
#cgo CPPFLAGS: -I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/System/Library/Frameworks/OpenGL.framework/Headers -I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/System/Library/Frameworks/AGL.framework/Headers
#cgo LDFLAGS: -headerpad_max_install_names -Wl,-syslibroot,/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk -mmacosx-version-min=10.7
#cgo LDFLAGS: -F/usr/local/Qt5.5.1/5.5/clang_64/lib -framework QtCore -framework QtConcurrent -framework QtBluetooth -framework DiskArbitration -framework IOKit -framework OpenGL -framework AGL
*/
import "C"

12
bluetooth/cgo_linux_386.go Executable file
View file

@ -0,0 +1,12 @@
package bluetooth
/*
#cgo CPPFLAGS: -pipe -O2 -Wall -W -D_REENTRANT
#cgo CPPFLAGS: -DQT_NO_DEBUG -DQT_CORE_LIB -DQT_CONCURRENT_LIB -DQT_BLUETOOTH_LIB
#cgo CPPFLAGS: -I/usr/local/Qt5.5.1/5.5/gcc/include -I/usr/local/Qt5.5.1/5.5/gcc/mkspecs/linux-g++
#cgo CPPFLAGS: -I/usr/local/Qt5.5.1/5.5/gcc/include/QtCore -I/usr/local/Qt5.5.1/5.5/gcc/include/QtConcurrent -I/usr/local/Qt5.5.1/5.5/gcc/include/QtBluetooth
#cgo LDFLAGS: -Wl,-O1 -Wl,-rpath,/usr/local/Qt5.5.1/5.5/gcc -Wl,-rpath,/usr/local/Qt5.5.1/5.5/gcc/lib
#cgo LDFLAGS: -L/usr/local/Qt5.5.1/5.5/gcc/lib -L/usr/lib -lQt5Core -lQt5Concurrent -lQt5Bluetooth -lpthread
*/
import "C"

12
bluetooth/cgo_linux_amd64.go Executable file
View file

@ -0,0 +1,12 @@
package bluetooth
/*
#cgo CPPFLAGS: -pipe -O2 -Wall -W -D_REENTRANT
#cgo CPPFLAGS: -DQT_NO_DEBUG -DQT_CORE_LIB -DQT_CONCURRENT_LIB -DQT_BLUETOOTH_LIB
#cgo CPPFLAGS: -I/usr/local/Qt5.5.1/5.5/gcc_64/include -I/usr/local/Qt5.5.1/5.5/gcc_64/mkspecs/linux-g++
#cgo CPPFLAGS: -I/usr/local/Qt5.5.1/5.5/gcc_64/include/QtCore -I/usr/local/Qt5.5.1/5.5/gcc_64/include/QtConcurrent -I/usr/local/Qt5.5.1/5.5/gcc_64/include/QtBluetooth
#cgo LDFLAGS: -Wl,-O1 -Wl,-rpath,/usr/local/Qt5.5.1/5.5/gcc_64 -Wl,-rpath,/usr/local/Qt5.5.1/5.5/gcc_64/lib
#cgo LDFLAGS: -L/usr/local/Qt5.5.1/5.5/gcc_64/lib -L/usr/lib64 -lQt5Core -lQt5Concurrent -lQt5Bluetooth -lpthread
*/
import "C"

12
bluetooth/cgo_windows_386.go Executable file
View file

@ -0,0 +1,12 @@
package bluetooth
/*
#cgo CPPFLAGS: -pipe -fno-keep-inline-dllexport -O2 -Wall -Wextra -fexceptions -mthreads
#cgo CPPFLAGS: -DUNICODE -DQT_NO_DEBUG -DQT_CORE_LIB -DQT_CONCURRENT_LIB -DQT_BLUETOOTH_LIB
#cgo CPPFLAGS: -IC:/Qt/Qt5.5.1/5.5/mingw492_32/include -IC:/Qt/Qt5.5.1/5.5/mingw492_32/mkspecs/win32-g++
#cgo CPPFLAGS: -IC:/Qt/Qt5.5.1/5.5/mingw492_32/include/QtCore -IC:/Qt/Qt5.5.1/5.5/mingw492_32/include/QtConcurrent -IC:/Qt/Qt5.5.1/5.5/mingw492_32/include/QtBluetooth
#cgo LDFLAGS: -Wl,-s -Wl,-subsystem,windows -mthreads
#cgo LDFLAGS: -LC:/Qt/Qt5.5.1/5.5/mingw492_32/bin -lQt5Core -lQt5Concurrent -lQt5Bluetooth
*/
import "C"

40
bluetooth/qbluetoothaddress.cpp Executable file
View file

@ -0,0 +1,40 @@
#include "qbluetoothaddress.h"
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QBluetoothAddress>
#include "_cgo_export.h"
class MyQBluetoothAddress: public QBluetoothAddress {
public:
};
QtObjectPtr QBluetoothAddress_NewQBluetoothAddress(){
return new QBluetoothAddress();
}
QtObjectPtr QBluetoothAddress_NewQBluetoothAddress4(QtObjectPtr other){
return new QBluetoothAddress(*static_cast<QBluetoothAddress*>(other));
}
QtObjectPtr QBluetoothAddress_NewQBluetoothAddress3(char* address){
return new QBluetoothAddress(QString(address));
}
void QBluetoothAddress_Clear(QtObjectPtr ptr){
static_cast<QBluetoothAddress*>(ptr)->clear();
}
int QBluetoothAddress_IsNull(QtObjectPtr ptr){
return static_cast<QBluetoothAddress*>(ptr)->isNull();
}
char* QBluetoothAddress_ToString(QtObjectPtr ptr){
return static_cast<QBluetoothAddress*>(ptr)->toString().toUtf8().data();
}
void QBluetoothAddress_DestroyQBluetoothAddress(QtObjectPtr ptr){
static_cast<QBluetoothAddress*>(ptr)->~QBluetoothAddress();
}

78
bluetooth/qbluetoothaddress.go Executable file
View file

@ -0,0 +1,78 @@
package bluetooth
//#include "qbluetoothaddress.h"
import "C"
import (
"unsafe"
)
type QBluetoothAddress struct {
ptr unsafe.Pointer
}
type QBluetoothAddressITF interface {
QBluetoothAddressPTR() *QBluetoothAddress
}
func (p *QBluetoothAddress) Pointer() unsafe.Pointer {
return p.ptr
}
func (p *QBluetoothAddress) SetPointer(ptr unsafe.Pointer) {
p.ptr = ptr
}
func PointerFromQBluetoothAddress(ptr QBluetoothAddressITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothAddressPTR().Pointer()
}
return nil
}
func QBluetoothAddressFromPointer(ptr unsafe.Pointer) *QBluetoothAddress {
var n = new(QBluetoothAddress)
n.SetPointer(ptr)
return n
}
func (ptr *QBluetoothAddress) QBluetoothAddressPTR() *QBluetoothAddress {
return ptr
}
func NewQBluetoothAddress() *QBluetoothAddress {
return QBluetoothAddressFromPointer(unsafe.Pointer(C.QBluetoothAddress_NewQBluetoothAddress()))
}
func NewQBluetoothAddress4(other QBluetoothAddressITF) *QBluetoothAddress {
return QBluetoothAddressFromPointer(unsafe.Pointer(C.QBluetoothAddress_NewQBluetoothAddress4(C.QtObjectPtr(PointerFromQBluetoothAddress(other)))))
}
func NewQBluetoothAddress3(address string) *QBluetoothAddress {
return QBluetoothAddressFromPointer(unsafe.Pointer(C.QBluetoothAddress_NewQBluetoothAddress3(C.CString(address))))
}
func (ptr *QBluetoothAddress) Clear() {
if ptr.Pointer() != nil {
C.QBluetoothAddress_Clear(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QBluetoothAddress) IsNull() bool {
if ptr.Pointer() != nil {
return C.QBluetoothAddress_IsNull(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothAddress) ToString() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothAddress_ToString(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothAddress) DestroyQBluetoothAddress() {
if ptr.Pointer() != nil {
C.QBluetoothAddress_DestroyQBluetoothAddress(C.QtObjectPtr(ptr.Pointer()))
}
}

16
bluetooth/qbluetoothaddress.h Executable file
View file

@ -0,0 +1,16 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QBluetoothAddress_NewQBluetoothAddress();
QtObjectPtr QBluetoothAddress_NewQBluetoothAddress4(QtObjectPtr other);
QtObjectPtr QBluetoothAddress_NewQBluetoothAddress3(char* address);
void QBluetoothAddress_Clear(QtObjectPtr ptr);
int QBluetoothAddress_IsNull(QtObjectPtr ptr);
char* QBluetoothAddress_ToString(QtObjectPtr ptr);
void QBluetoothAddress_DestroyQBluetoothAddress(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

73
bluetooth/qbluetoothdevicediscoveryagent.cpp Executable file
View file

@ -0,0 +1,73 @@
#include "qbluetoothdevicediscoveryagent.h"
#include <QMetaObject>
#include <QObject>
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QBluetoothAddress>
#include <QBluetoothDeviceDiscoveryAgent>
#include "_cgo_export.h"
class MyQBluetoothDeviceDiscoveryAgent: public QBluetoothDeviceDiscoveryAgent {
public:
void Signal_Canceled(){callbackQBluetoothDeviceDiscoveryAgentCanceled(this->objectName().toUtf8().data());};
void Signal_Finished(){callbackQBluetoothDeviceDiscoveryAgentFinished(this->objectName().toUtf8().data());};
};
void QBluetoothDeviceDiscoveryAgent_ConnectCanceled(QtObjectPtr ptr){
QObject::connect(static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothDeviceDiscoveryAgent::*)()>(&QBluetoothDeviceDiscoveryAgent::canceled), static_cast<MyQBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothDeviceDiscoveryAgent::*)()>(&MyQBluetoothDeviceDiscoveryAgent::Signal_Canceled));;
}
void QBluetoothDeviceDiscoveryAgent_DisconnectCanceled(QtObjectPtr ptr){
QObject::disconnect(static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothDeviceDiscoveryAgent::*)()>(&QBluetoothDeviceDiscoveryAgent::canceled), static_cast<MyQBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothDeviceDiscoveryAgent::*)()>(&MyQBluetoothDeviceDiscoveryAgent::Signal_Canceled));;
}
void QBluetoothDeviceDiscoveryAgent_ConnectFinished(QtObjectPtr ptr){
QObject::connect(static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothDeviceDiscoveryAgent::*)()>(&QBluetoothDeviceDiscoveryAgent::finished), static_cast<MyQBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothDeviceDiscoveryAgent::*)()>(&MyQBluetoothDeviceDiscoveryAgent::Signal_Finished));;
}
void QBluetoothDeviceDiscoveryAgent_DisconnectFinished(QtObjectPtr ptr){
QObject::disconnect(static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothDeviceDiscoveryAgent::*)()>(&QBluetoothDeviceDiscoveryAgent::finished), static_cast<MyQBluetoothDeviceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothDeviceDiscoveryAgent::*)()>(&MyQBluetoothDeviceDiscoveryAgent::Signal_Finished));;
}
QtObjectPtr QBluetoothDeviceDiscoveryAgent_NewQBluetoothDeviceDiscoveryAgent(QtObjectPtr parent){
return new QBluetoothDeviceDiscoveryAgent(static_cast<QObject*>(parent));
}
QtObjectPtr QBluetoothDeviceDiscoveryAgent_NewQBluetoothDeviceDiscoveryAgent2(QtObjectPtr deviceAdapter, QtObjectPtr parent){
return new QBluetoothDeviceDiscoveryAgent(*static_cast<QBluetoothAddress*>(deviceAdapter), static_cast<QObject*>(parent));
}
int QBluetoothDeviceDiscoveryAgent_Error(QtObjectPtr ptr){
return static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr)->error();
}
char* QBluetoothDeviceDiscoveryAgent_ErrorString(QtObjectPtr ptr){
return static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr)->errorString().toUtf8().data();
}
int QBluetoothDeviceDiscoveryAgent_InquiryType(QtObjectPtr ptr){
return static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr)->inquiryType();
}
int QBluetoothDeviceDiscoveryAgent_IsActive(QtObjectPtr ptr){
return static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr)->isActive();
}
void QBluetoothDeviceDiscoveryAgent_SetInquiryType(QtObjectPtr ptr, int ty){
static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr)->setInquiryType(static_cast<QBluetoothDeviceDiscoveryAgent::InquiryType>(ty));
}
void QBluetoothDeviceDiscoveryAgent_Start(QtObjectPtr ptr){
QMetaObject::invokeMethod(static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr), "start");
}
void QBluetoothDeviceDiscoveryAgent_Stop(QtObjectPtr ptr){
QMetaObject::invokeMethod(static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr), "stop");
}
void QBluetoothDeviceDiscoveryAgent_DestroyQBluetoothDeviceDiscoveryAgent(QtObjectPtr ptr){
static_cast<QBluetoothDeviceDiscoveryAgent*>(ptr)->~QBluetoothDeviceDiscoveryAgent();
}

157
bluetooth/qbluetoothdevicediscoveryagent.go Executable file
View file

@ -0,0 +1,157 @@
package bluetooth
//#include "qbluetoothdevicediscoveryagent.h"
import "C"
import (
"github.com/therecipe/qt"
"github.com/therecipe/qt/core"
"unsafe"
)
type QBluetoothDeviceDiscoveryAgent struct {
core.QObject
}
type QBluetoothDeviceDiscoveryAgentITF interface {
core.QObjectITF
QBluetoothDeviceDiscoveryAgentPTR() *QBluetoothDeviceDiscoveryAgent
}
func PointerFromQBluetoothDeviceDiscoveryAgent(ptr QBluetoothDeviceDiscoveryAgentITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothDeviceDiscoveryAgentPTR().Pointer()
}
return nil
}
func QBluetoothDeviceDiscoveryAgentFromPointer(ptr unsafe.Pointer) *QBluetoothDeviceDiscoveryAgent {
var n = new(QBluetoothDeviceDiscoveryAgent)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QBluetoothDeviceDiscoveryAgent_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QBluetoothDeviceDiscoveryAgent) QBluetoothDeviceDiscoveryAgentPTR() *QBluetoothDeviceDiscoveryAgent {
return ptr
}
//QBluetoothDeviceDiscoveryAgent::Error
type QBluetoothDeviceDiscoveryAgent__Error int
var (
QBluetoothDeviceDiscoveryAgent__NoError = QBluetoothDeviceDiscoveryAgent__Error(0)
QBluetoothDeviceDiscoveryAgent__InputOutputError = QBluetoothDeviceDiscoveryAgent__Error(1)
QBluetoothDeviceDiscoveryAgent__PoweredOffError = QBluetoothDeviceDiscoveryAgent__Error(2)
QBluetoothDeviceDiscoveryAgent__InvalidBluetoothAdapterError = QBluetoothDeviceDiscoveryAgent__Error(3)
QBluetoothDeviceDiscoveryAgent__UnsupportedPlatformError = QBluetoothDeviceDiscoveryAgent__Error(4)
QBluetoothDeviceDiscoveryAgent__UnknownError = QBluetoothDeviceDiscoveryAgent__Error(100)
)
//QBluetoothDeviceDiscoveryAgent::InquiryType
type QBluetoothDeviceDiscoveryAgent__InquiryType int
var (
QBluetoothDeviceDiscoveryAgent__GeneralUnlimitedInquiry = QBluetoothDeviceDiscoveryAgent__InquiryType(0)
QBluetoothDeviceDiscoveryAgent__LimitedInquiry = QBluetoothDeviceDiscoveryAgent__InquiryType(1)
)
func (ptr *QBluetoothDeviceDiscoveryAgent) ConnectCanceled(f func()) {
if ptr.Pointer() != nil {
C.QBluetoothDeviceDiscoveryAgent_ConnectCanceled(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "canceled", f)
}
}
func (ptr *QBluetoothDeviceDiscoveryAgent) DisconnectCanceled() {
if ptr.Pointer() != nil {
C.QBluetoothDeviceDiscoveryAgent_DisconnectCanceled(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "canceled")
}
}
//export callbackQBluetoothDeviceDiscoveryAgentCanceled
func callbackQBluetoothDeviceDiscoveryAgentCanceled(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "canceled").(func())()
}
func (ptr *QBluetoothDeviceDiscoveryAgent) ConnectFinished(f func()) {
if ptr.Pointer() != nil {
C.QBluetoothDeviceDiscoveryAgent_ConnectFinished(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "finished", f)
}
}
func (ptr *QBluetoothDeviceDiscoveryAgent) DisconnectFinished() {
if ptr.Pointer() != nil {
C.QBluetoothDeviceDiscoveryAgent_DisconnectFinished(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "finished")
}
}
//export callbackQBluetoothDeviceDiscoveryAgentFinished
func callbackQBluetoothDeviceDiscoveryAgentFinished(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "finished").(func())()
}
func NewQBluetoothDeviceDiscoveryAgent(parent core.QObjectITF) *QBluetoothDeviceDiscoveryAgent {
return QBluetoothDeviceDiscoveryAgentFromPointer(unsafe.Pointer(C.QBluetoothDeviceDiscoveryAgent_NewQBluetoothDeviceDiscoveryAgent(C.QtObjectPtr(core.PointerFromQObject(parent)))))
}
func NewQBluetoothDeviceDiscoveryAgent2(deviceAdapter QBluetoothAddressITF, parent core.QObjectITF) *QBluetoothDeviceDiscoveryAgent {
return QBluetoothDeviceDiscoveryAgentFromPointer(unsafe.Pointer(C.QBluetoothDeviceDiscoveryAgent_NewQBluetoothDeviceDiscoveryAgent2(C.QtObjectPtr(PointerFromQBluetoothAddress(deviceAdapter)), C.QtObjectPtr(core.PointerFromQObject(parent)))))
}
func (ptr *QBluetoothDeviceDiscoveryAgent) Error() QBluetoothDeviceDiscoveryAgent__Error {
if ptr.Pointer() != nil {
return QBluetoothDeviceDiscoveryAgent__Error(C.QBluetoothDeviceDiscoveryAgent_Error(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothDeviceDiscoveryAgent) ErrorString() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothDeviceDiscoveryAgent_ErrorString(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothDeviceDiscoveryAgent) InquiryType() QBluetoothDeviceDiscoveryAgent__InquiryType {
if ptr.Pointer() != nil {
return QBluetoothDeviceDiscoveryAgent__InquiryType(C.QBluetoothDeviceDiscoveryAgent_InquiryType(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothDeviceDiscoveryAgent) IsActive() bool {
if ptr.Pointer() != nil {
return C.QBluetoothDeviceDiscoveryAgent_IsActive(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothDeviceDiscoveryAgent) SetInquiryType(ty QBluetoothDeviceDiscoveryAgent__InquiryType) {
if ptr.Pointer() != nil {
C.QBluetoothDeviceDiscoveryAgent_SetInquiryType(C.QtObjectPtr(ptr.Pointer()), C.int(ty))
}
}
func (ptr *QBluetoothDeviceDiscoveryAgent) Start() {
if ptr.Pointer() != nil {
C.QBluetoothDeviceDiscoveryAgent_Start(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QBluetoothDeviceDiscoveryAgent) Stop() {
if ptr.Pointer() != nil {
C.QBluetoothDeviceDiscoveryAgent_Stop(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QBluetoothDeviceDiscoveryAgent) DestroyQBluetoothDeviceDiscoveryAgent() {
if ptr.Pointer() != nil {
C.QBluetoothDeviceDiscoveryAgent_DestroyQBluetoothDeviceDiscoveryAgent(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

23
bluetooth/qbluetoothdevicediscoveryagent.h Executable file
View file

@ -0,0 +1,23 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
void QBluetoothDeviceDiscoveryAgent_ConnectCanceled(QtObjectPtr ptr);
void QBluetoothDeviceDiscoveryAgent_DisconnectCanceled(QtObjectPtr ptr);
void QBluetoothDeviceDiscoveryAgent_ConnectFinished(QtObjectPtr ptr);
void QBluetoothDeviceDiscoveryAgent_DisconnectFinished(QtObjectPtr ptr);
QtObjectPtr QBluetoothDeviceDiscoveryAgent_NewQBluetoothDeviceDiscoveryAgent(QtObjectPtr parent);
QtObjectPtr QBluetoothDeviceDiscoveryAgent_NewQBluetoothDeviceDiscoveryAgent2(QtObjectPtr deviceAdapter, QtObjectPtr parent);
int QBluetoothDeviceDiscoveryAgent_Error(QtObjectPtr ptr);
char* QBluetoothDeviceDiscoveryAgent_ErrorString(QtObjectPtr ptr);
int QBluetoothDeviceDiscoveryAgent_InquiryType(QtObjectPtr ptr);
int QBluetoothDeviceDiscoveryAgent_IsActive(QtObjectPtr ptr);
void QBluetoothDeviceDiscoveryAgent_SetInquiryType(QtObjectPtr ptr, int ty);
void QBluetoothDeviceDiscoveryAgent_Start(QtObjectPtr ptr);
void QBluetoothDeviceDiscoveryAgent_Stop(QtObjectPtr ptr);
void QBluetoothDeviceDiscoveryAgent_DestroyQBluetoothDeviceDiscoveryAgent(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

65
bluetooth/qbluetoothdeviceinfo.cpp Executable file
View file

@ -0,0 +1,65 @@
#include "qbluetoothdeviceinfo.h"
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QBluetoothUuid>
#include <QBluetoothDeviceInfo>
#include "_cgo_export.h"
class MyQBluetoothDeviceInfo: public QBluetoothDeviceInfo {
public:
};
QtObjectPtr QBluetoothDeviceInfo_NewQBluetoothDeviceInfo(){
return new QBluetoothDeviceInfo();
}
QtObjectPtr QBluetoothDeviceInfo_NewQBluetoothDeviceInfo4(QtObjectPtr other){
return new QBluetoothDeviceInfo(*static_cast<QBluetoothDeviceInfo*>(other));
}
int QBluetoothDeviceInfo_CoreConfigurations(QtObjectPtr ptr){
return static_cast<QBluetoothDeviceInfo*>(ptr)->coreConfigurations();
}
int QBluetoothDeviceInfo_IsCached(QtObjectPtr ptr){
return static_cast<QBluetoothDeviceInfo*>(ptr)->isCached();
}
int QBluetoothDeviceInfo_IsValid(QtObjectPtr ptr){
return static_cast<QBluetoothDeviceInfo*>(ptr)->isValid();
}
int QBluetoothDeviceInfo_MajorDeviceClass(QtObjectPtr ptr){
return static_cast<QBluetoothDeviceInfo*>(ptr)->majorDeviceClass();
}
char* QBluetoothDeviceInfo_Name(QtObjectPtr ptr){
return static_cast<QBluetoothDeviceInfo*>(ptr)->name().toUtf8().data();
}
int QBluetoothDeviceInfo_ServiceClasses(QtObjectPtr ptr){
return static_cast<QBluetoothDeviceInfo*>(ptr)->serviceClasses();
}
int QBluetoothDeviceInfo_ServiceUuidsCompleteness(QtObjectPtr ptr){
return static_cast<QBluetoothDeviceInfo*>(ptr)->serviceUuidsCompleteness();
}
void QBluetoothDeviceInfo_SetCached(QtObjectPtr ptr, int cached){
static_cast<QBluetoothDeviceInfo*>(ptr)->setCached(cached != 0);
}
void QBluetoothDeviceInfo_SetCoreConfigurations(QtObjectPtr ptr, int coreConfigs){
static_cast<QBluetoothDeviceInfo*>(ptr)->setCoreConfigurations(static_cast<QBluetoothDeviceInfo::CoreConfiguration>(coreConfigs));
}
void QBluetoothDeviceInfo_SetDeviceUuid(QtObjectPtr ptr, QtObjectPtr uuid){
static_cast<QBluetoothDeviceInfo*>(ptr)->setDeviceUuid(*static_cast<QBluetoothUuid*>(uuid));
}
void QBluetoothDeviceInfo_DestroyQBluetoothDeviceInfo(QtObjectPtr ptr){
static_cast<QBluetoothDeviceInfo*>(ptr)->~QBluetoothDeviceInfo();
}

308
bluetooth/qbluetoothdeviceinfo.go Executable file
View file

@ -0,0 +1,308 @@
package bluetooth
//#include "qbluetoothdeviceinfo.h"
import "C"
import (
"github.com/therecipe/qt"
"unsafe"
)
type QBluetoothDeviceInfo struct {
ptr unsafe.Pointer
}
type QBluetoothDeviceInfoITF interface {
QBluetoothDeviceInfoPTR() *QBluetoothDeviceInfo
}
func (p *QBluetoothDeviceInfo) Pointer() unsafe.Pointer {
return p.ptr
}
func (p *QBluetoothDeviceInfo) SetPointer(ptr unsafe.Pointer) {
p.ptr = ptr
}
func PointerFromQBluetoothDeviceInfo(ptr QBluetoothDeviceInfoITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothDeviceInfoPTR().Pointer()
}
return nil
}
func QBluetoothDeviceInfoFromPointer(ptr unsafe.Pointer) *QBluetoothDeviceInfo {
var n = new(QBluetoothDeviceInfo)
n.SetPointer(ptr)
return n
}
func (ptr *QBluetoothDeviceInfo) QBluetoothDeviceInfoPTR() *QBluetoothDeviceInfo {
return ptr
}
//QBluetoothDeviceInfo::CoreConfiguration
type QBluetoothDeviceInfo__CoreConfiguration int
var (
QBluetoothDeviceInfo__UnknownCoreConfiguration = QBluetoothDeviceInfo__CoreConfiguration(0x0)
QBluetoothDeviceInfo__LowEnergyCoreConfiguration = QBluetoothDeviceInfo__CoreConfiguration(0x01)
QBluetoothDeviceInfo__BaseRateCoreConfiguration = QBluetoothDeviceInfo__CoreConfiguration(0x02)
QBluetoothDeviceInfo__BaseRateAndLowEnergyCoreConfiguration = QBluetoothDeviceInfo__CoreConfiguration(0x03)
)
//QBluetoothDeviceInfo::DataCompleteness
type QBluetoothDeviceInfo__DataCompleteness int
var (
QBluetoothDeviceInfo__DataComplete = QBluetoothDeviceInfo__DataCompleteness(0)
QBluetoothDeviceInfo__DataIncomplete = QBluetoothDeviceInfo__DataCompleteness(1)
QBluetoothDeviceInfo__DataUnavailable = QBluetoothDeviceInfo__DataCompleteness(2)
)
//QBluetoothDeviceInfo::MajorDeviceClass
type QBluetoothDeviceInfo__MajorDeviceClass int
var (
QBluetoothDeviceInfo__MiscellaneousDevice = QBluetoothDeviceInfo__MajorDeviceClass(0)
QBluetoothDeviceInfo__ComputerDevice = QBluetoothDeviceInfo__MajorDeviceClass(1)
QBluetoothDeviceInfo__PhoneDevice = QBluetoothDeviceInfo__MajorDeviceClass(2)
QBluetoothDeviceInfo__LANAccessDevice = QBluetoothDeviceInfo__MajorDeviceClass(3)
QBluetoothDeviceInfo__AudioVideoDevice = QBluetoothDeviceInfo__MajorDeviceClass(4)
QBluetoothDeviceInfo__PeripheralDevice = QBluetoothDeviceInfo__MajorDeviceClass(5)
QBluetoothDeviceInfo__ImagingDevice = QBluetoothDeviceInfo__MajorDeviceClass(6)
QBluetoothDeviceInfo__WearableDevice = QBluetoothDeviceInfo__MajorDeviceClass(7)
QBluetoothDeviceInfo__ToyDevice = QBluetoothDeviceInfo__MajorDeviceClass(8)
QBluetoothDeviceInfo__HealthDevice = QBluetoothDeviceInfo__MajorDeviceClass(9)
QBluetoothDeviceInfo__UncategorizedDevice = QBluetoothDeviceInfo__MajorDeviceClass(31)
)
//QBluetoothDeviceInfo::MinorAudioVideoClass
type QBluetoothDeviceInfo__MinorAudioVideoClass int
var (
QBluetoothDeviceInfo__UncategorizedAudioVideoDevice = QBluetoothDeviceInfo__MinorAudioVideoClass(0)
QBluetoothDeviceInfo__WearableHeadsetDevice = QBluetoothDeviceInfo__MinorAudioVideoClass(1)
QBluetoothDeviceInfo__HandsFreeDevice = QBluetoothDeviceInfo__MinorAudioVideoClass(2)
QBluetoothDeviceInfo__Microphone = QBluetoothDeviceInfo__MinorAudioVideoClass(4)
QBluetoothDeviceInfo__Loudspeaker = QBluetoothDeviceInfo__MinorAudioVideoClass(5)
QBluetoothDeviceInfo__Headphones = QBluetoothDeviceInfo__MinorAudioVideoClass(6)
QBluetoothDeviceInfo__PortableAudioDevice = QBluetoothDeviceInfo__MinorAudioVideoClass(7)
QBluetoothDeviceInfo__CarAudio = QBluetoothDeviceInfo__MinorAudioVideoClass(8)
QBluetoothDeviceInfo__SetTopBox = QBluetoothDeviceInfo__MinorAudioVideoClass(9)
QBluetoothDeviceInfo__HiFiAudioDevice = QBluetoothDeviceInfo__MinorAudioVideoClass(10)
QBluetoothDeviceInfo__Vcr = QBluetoothDeviceInfo__MinorAudioVideoClass(11)
QBluetoothDeviceInfo__VideoCamera = QBluetoothDeviceInfo__MinorAudioVideoClass(12)
QBluetoothDeviceInfo__Camcorder = QBluetoothDeviceInfo__MinorAudioVideoClass(13)
QBluetoothDeviceInfo__VideoMonitor = QBluetoothDeviceInfo__MinorAudioVideoClass(14)
QBluetoothDeviceInfo__VideoDisplayAndLoudspeaker = QBluetoothDeviceInfo__MinorAudioVideoClass(15)
QBluetoothDeviceInfo__VideoConferencing = QBluetoothDeviceInfo__MinorAudioVideoClass(16)
QBluetoothDeviceInfo__GamingDevice = QBluetoothDeviceInfo__MinorAudioVideoClass(18)
)
//QBluetoothDeviceInfo::MinorComputerClass
type QBluetoothDeviceInfo__MinorComputerClass int
var (
QBluetoothDeviceInfo__UncategorizedComputer = QBluetoothDeviceInfo__MinorComputerClass(0)
QBluetoothDeviceInfo__DesktopComputer = QBluetoothDeviceInfo__MinorComputerClass(1)
QBluetoothDeviceInfo__ServerComputer = QBluetoothDeviceInfo__MinorComputerClass(2)
QBluetoothDeviceInfo__LaptopComputer = QBluetoothDeviceInfo__MinorComputerClass(3)
QBluetoothDeviceInfo__HandheldClamShellComputer = QBluetoothDeviceInfo__MinorComputerClass(4)
QBluetoothDeviceInfo__HandheldComputer = QBluetoothDeviceInfo__MinorComputerClass(5)
QBluetoothDeviceInfo__WearableComputer = QBluetoothDeviceInfo__MinorComputerClass(6)
)
//QBluetoothDeviceInfo::MinorHealthClass
type QBluetoothDeviceInfo__MinorHealthClass int
var (
QBluetoothDeviceInfo__UncategorizedHealthDevice = QBluetoothDeviceInfo__MinorHealthClass(0)
QBluetoothDeviceInfo__HealthBloodPressureMonitor = QBluetoothDeviceInfo__MinorHealthClass(0x1)
QBluetoothDeviceInfo__HealthThermometer = QBluetoothDeviceInfo__MinorHealthClass(0x2)
QBluetoothDeviceInfo__HealthWeightScale = QBluetoothDeviceInfo__MinorHealthClass(0x3)
QBluetoothDeviceInfo__HealthGlucoseMeter = QBluetoothDeviceInfo__MinorHealthClass(0x4)
QBluetoothDeviceInfo__HealthPulseOximeter = QBluetoothDeviceInfo__MinorHealthClass(0x5)
QBluetoothDeviceInfo__HealthDataDisplay = QBluetoothDeviceInfo__MinorHealthClass(0x7)
QBluetoothDeviceInfo__HealthStepCounter = QBluetoothDeviceInfo__MinorHealthClass(0x8)
)
//QBluetoothDeviceInfo::MinorImagingClass
type QBluetoothDeviceInfo__MinorImagingClass int
var (
QBluetoothDeviceInfo__UncategorizedImagingDevice = QBluetoothDeviceInfo__MinorImagingClass(0)
QBluetoothDeviceInfo__ImageDisplay = QBluetoothDeviceInfo__MinorImagingClass(0x04)
QBluetoothDeviceInfo__ImageCamera = QBluetoothDeviceInfo__MinorImagingClass(0x08)
QBluetoothDeviceInfo__ImageScanner = QBluetoothDeviceInfo__MinorImagingClass(0x10)
QBluetoothDeviceInfo__ImagePrinter = QBluetoothDeviceInfo__MinorImagingClass(0x20)
)
//QBluetoothDeviceInfo::MinorMiscellaneousClass
type QBluetoothDeviceInfo__MinorMiscellaneousClass int
var (
QBluetoothDeviceInfo__UncategorizedMiscellaneous = QBluetoothDeviceInfo__MinorMiscellaneousClass(0)
)
//QBluetoothDeviceInfo::MinorNetworkClass
type QBluetoothDeviceInfo__MinorNetworkClass int
var (
QBluetoothDeviceInfo__NetworkFullService = QBluetoothDeviceInfo__MinorNetworkClass(0x00)
QBluetoothDeviceInfo__NetworkLoadFactorOne = QBluetoothDeviceInfo__MinorNetworkClass(0x08)
QBluetoothDeviceInfo__NetworkLoadFactorTwo = QBluetoothDeviceInfo__MinorNetworkClass(0x10)
QBluetoothDeviceInfo__NetworkLoadFactorThree = QBluetoothDeviceInfo__MinorNetworkClass(0x18)
QBluetoothDeviceInfo__NetworkLoadFactorFour = QBluetoothDeviceInfo__MinorNetworkClass(0x20)
QBluetoothDeviceInfo__NetworkLoadFactorFive = QBluetoothDeviceInfo__MinorNetworkClass(0x28)
QBluetoothDeviceInfo__NetworkLoadFactorSix = QBluetoothDeviceInfo__MinorNetworkClass(0x30)
QBluetoothDeviceInfo__NetworkNoService = QBluetoothDeviceInfo__MinorNetworkClass(0x38)
)
//QBluetoothDeviceInfo::MinorPeripheralClass
type QBluetoothDeviceInfo__MinorPeripheralClass int
var (
QBluetoothDeviceInfo__UncategorizedPeripheral = QBluetoothDeviceInfo__MinorPeripheralClass(0)
QBluetoothDeviceInfo__KeyboardPeripheral = QBluetoothDeviceInfo__MinorPeripheralClass(0x10)
QBluetoothDeviceInfo__PointingDevicePeripheral = QBluetoothDeviceInfo__MinorPeripheralClass(0x20)
QBluetoothDeviceInfo__KeyboardWithPointingDevicePeripheral = QBluetoothDeviceInfo__MinorPeripheralClass(0x30)
QBluetoothDeviceInfo__JoystickPeripheral = QBluetoothDeviceInfo__MinorPeripheralClass(0x01)
QBluetoothDeviceInfo__GamepadPeripheral = QBluetoothDeviceInfo__MinorPeripheralClass(0x02)
QBluetoothDeviceInfo__RemoteControlPeripheral = QBluetoothDeviceInfo__MinorPeripheralClass(0x03)
QBluetoothDeviceInfo__SensingDevicePeripheral = QBluetoothDeviceInfo__MinorPeripheralClass(0x04)
QBluetoothDeviceInfo__DigitizerTabletPeripheral = QBluetoothDeviceInfo__MinorPeripheralClass(0x05)
QBluetoothDeviceInfo__CardReaderPeripheral = QBluetoothDeviceInfo__MinorPeripheralClass(0x06)
)
//QBluetoothDeviceInfo::MinorPhoneClass
type QBluetoothDeviceInfo__MinorPhoneClass int
var (
QBluetoothDeviceInfo__UncategorizedPhone = QBluetoothDeviceInfo__MinorPhoneClass(0)
QBluetoothDeviceInfo__CellularPhone = QBluetoothDeviceInfo__MinorPhoneClass(1)
QBluetoothDeviceInfo__CordlessPhone = QBluetoothDeviceInfo__MinorPhoneClass(2)
QBluetoothDeviceInfo__SmartPhone = QBluetoothDeviceInfo__MinorPhoneClass(3)
QBluetoothDeviceInfo__WiredModemOrVoiceGatewayPhone = QBluetoothDeviceInfo__MinorPhoneClass(4)
QBluetoothDeviceInfo__CommonIsdnAccessPhone = QBluetoothDeviceInfo__MinorPhoneClass(5)
)
//QBluetoothDeviceInfo::MinorToyClass
type QBluetoothDeviceInfo__MinorToyClass int
var (
QBluetoothDeviceInfo__UncategorizedToy = QBluetoothDeviceInfo__MinorToyClass(0)
QBluetoothDeviceInfo__ToyRobot = QBluetoothDeviceInfo__MinorToyClass(1)
QBluetoothDeviceInfo__ToyVehicle = QBluetoothDeviceInfo__MinorToyClass(2)
QBluetoothDeviceInfo__ToyDoll = QBluetoothDeviceInfo__MinorToyClass(3)
QBluetoothDeviceInfo__ToyController = QBluetoothDeviceInfo__MinorToyClass(4)
QBluetoothDeviceInfo__ToyGame = QBluetoothDeviceInfo__MinorToyClass(5)
)
//QBluetoothDeviceInfo::MinorWearableClass
type QBluetoothDeviceInfo__MinorWearableClass int
var (
QBluetoothDeviceInfo__UncategorizedWearableDevice = QBluetoothDeviceInfo__MinorWearableClass(0)
QBluetoothDeviceInfo__WearableWristWatch = QBluetoothDeviceInfo__MinorWearableClass(1)
QBluetoothDeviceInfo__WearablePager = QBluetoothDeviceInfo__MinorWearableClass(2)
QBluetoothDeviceInfo__WearableJacket = QBluetoothDeviceInfo__MinorWearableClass(3)
QBluetoothDeviceInfo__WearableHelmet = QBluetoothDeviceInfo__MinorWearableClass(4)
QBluetoothDeviceInfo__WearableGlasses = QBluetoothDeviceInfo__MinorWearableClass(5)
)
//QBluetoothDeviceInfo::ServiceClass
type QBluetoothDeviceInfo__ServiceClass int
var (
QBluetoothDeviceInfo__NoService = QBluetoothDeviceInfo__ServiceClass(0x0000)
QBluetoothDeviceInfo__PositioningService = QBluetoothDeviceInfo__ServiceClass(0x0001)
QBluetoothDeviceInfo__NetworkingService = QBluetoothDeviceInfo__ServiceClass(0x0002)
QBluetoothDeviceInfo__RenderingService = QBluetoothDeviceInfo__ServiceClass(0x0004)
QBluetoothDeviceInfo__CapturingService = QBluetoothDeviceInfo__ServiceClass(0x0008)
QBluetoothDeviceInfo__ObjectTransferService = QBluetoothDeviceInfo__ServiceClass(0x0010)
QBluetoothDeviceInfo__AudioService = QBluetoothDeviceInfo__ServiceClass(0x0020)
QBluetoothDeviceInfo__TelephonyService = QBluetoothDeviceInfo__ServiceClass(0x0040)
QBluetoothDeviceInfo__InformationService = QBluetoothDeviceInfo__ServiceClass(0x0080)
QBluetoothDeviceInfo__AllServices = QBluetoothDeviceInfo__ServiceClass(0x07ff)
)
func NewQBluetoothDeviceInfo() *QBluetoothDeviceInfo {
return QBluetoothDeviceInfoFromPointer(unsafe.Pointer(C.QBluetoothDeviceInfo_NewQBluetoothDeviceInfo()))
}
func NewQBluetoothDeviceInfo4(other QBluetoothDeviceInfoITF) *QBluetoothDeviceInfo {
return QBluetoothDeviceInfoFromPointer(unsafe.Pointer(C.QBluetoothDeviceInfo_NewQBluetoothDeviceInfo4(C.QtObjectPtr(PointerFromQBluetoothDeviceInfo(other)))))
}
func (ptr *QBluetoothDeviceInfo) CoreConfigurations() QBluetoothDeviceInfo__CoreConfiguration {
if ptr.Pointer() != nil {
return QBluetoothDeviceInfo__CoreConfiguration(C.QBluetoothDeviceInfo_CoreConfigurations(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothDeviceInfo) IsCached() bool {
if ptr.Pointer() != nil {
return C.QBluetoothDeviceInfo_IsCached(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothDeviceInfo) IsValid() bool {
if ptr.Pointer() != nil {
return C.QBluetoothDeviceInfo_IsValid(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothDeviceInfo) MajorDeviceClass() QBluetoothDeviceInfo__MajorDeviceClass {
if ptr.Pointer() != nil {
return QBluetoothDeviceInfo__MajorDeviceClass(C.QBluetoothDeviceInfo_MajorDeviceClass(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothDeviceInfo) Name() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothDeviceInfo_Name(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothDeviceInfo) ServiceClasses() QBluetoothDeviceInfo__ServiceClass {
if ptr.Pointer() != nil {
return QBluetoothDeviceInfo__ServiceClass(C.QBluetoothDeviceInfo_ServiceClasses(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothDeviceInfo) ServiceUuidsCompleteness() QBluetoothDeviceInfo__DataCompleteness {
if ptr.Pointer() != nil {
return QBluetoothDeviceInfo__DataCompleteness(C.QBluetoothDeviceInfo_ServiceUuidsCompleteness(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothDeviceInfo) SetCached(cached bool) {
if ptr.Pointer() != nil {
C.QBluetoothDeviceInfo_SetCached(C.QtObjectPtr(ptr.Pointer()), C.int(qt.GoBoolToInt(cached)))
}
}
func (ptr *QBluetoothDeviceInfo) SetCoreConfigurations(coreConfigs QBluetoothDeviceInfo__CoreConfiguration) {
if ptr.Pointer() != nil {
C.QBluetoothDeviceInfo_SetCoreConfigurations(C.QtObjectPtr(ptr.Pointer()), C.int(coreConfigs))
}
}
func (ptr *QBluetoothDeviceInfo) SetDeviceUuid(uuid QBluetoothUuidITF) {
if ptr.Pointer() != nil {
C.QBluetoothDeviceInfo_SetDeviceUuid(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothUuid(uuid)))
}
}
func (ptr *QBluetoothDeviceInfo) DestroyQBluetoothDeviceInfo() {
if ptr.Pointer() != nil {
C.QBluetoothDeviceInfo_DestroyQBluetoothDeviceInfo(C.QtObjectPtr(ptr.Pointer()))
}
}

22
bluetooth/qbluetoothdeviceinfo.h Executable file
View file

@ -0,0 +1,22 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QBluetoothDeviceInfo_NewQBluetoothDeviceInfo();
QtObjectPtr QBluetoothDeviceInfo_NewQBluetoothDeviceInfo4(QtObjectPtr other);
int QBluetoothDeviceInfo_CoreConfigurations(QtObjectPtr ptr);
int QBluetoothDeviceInfo_IsCached(QtObjectPtr ptr);
int QBluetoothDeviceInfo_IsValid(QtObjectPtr ptr);
int QBluetoothDeviceInfo_MajorDeviceClass(QtObjectPtr ptr);
char* QBluetoothDeviceInfo_Name(QtObjectPtr ptr);
int QBluetoothDeviceInfo_ServiceClasses(QtObjectPtr ptr);
int QBluetoothDeviceInfo_ServiceUuidsCompleteness(QtObjectPtr ptr);
void QBluetoothDeviceInfo_SetCached(QtObjectPtr ptr, int cached);
void QBluetoothDeviceInfo_SetCoreConfigurations(QtObjectPtr ptr, int coreConfigs);
void QBluetoothDeviceInfo_SetDeviceUuid(QtObjectPtr ptr, QtObjectPtr uuid);
void QBluetoothDeviceInfo_DestroyQBluetoothDeviceInfo(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

37
bluetooth/qbluetoothhostinfo.cpp Executable file
View file

@ -0,0 +1,37 @@
#include "qbluetoothhostinfo.h"
#include <QBluetoothAddress>
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QBluetoothHostInfo>
#include "_cgo_export.h"
class MyQBluetoothHostInfo: public QBluetoothHostInfo {
public:
};
QtObjectPtr QBluetoothHostInfo_NewQBluetoothHostInfo(){
return new QBluetoothHostInfo();
}
QtObjectPtr QBluetoothHostInfo_NewQBluetoothHostInfo2(QtObjectPtr other){
return new QBluetoothHostInfo(*static_cast<QBluetoothHostInfo*>(other));
}
char* QBluetoothHostInfo_Name(QtObjectPtr ptr){
return static_cast<QBluetoothHostInfo*>(ptr)->name().toUtf8().data();
}
void QBluetoothHostInfo_SetAddress(QtObjectPtr ptr, QtObjectPtr address){
static_cast<QBluetoothHostInfo*>(ptr)->setAddress(*static_cast<QBluetoothAddress*>(address));
}
void QBluetoothHostInfo_SetName(QtObjectPtr ptr, char* name){
static_cast<QBluetoothHostInfo*>(ptr)->setName(QString(name));
}
void QBluetoothHostInfo_DestroyQBluetoothHostInfo(QtObjectPtr ptr){
static_cast<QBluetoothHostInfo*>(ptr)->~QBluetoothHostInfo();
}

73
bluetooth/qbluetoothhostinfo.go Executable file
View file

@ -0,0 +1,73 @@
package bluetooth
//#include "qbluetoothhostinfo.h"
import "C"
import (
"unsafe"
)
type QBluetoothHostInfo struct {
ptr unsafe.Pointer
}
type QBluetoothHostInfoITF interface {
QBluetoothHostInfoPTR() *QBluetoothHostInfo
}
func (p *QBluetoothHostInfo) Pointer() unsafe.Pointer {
return p.ptr
}
func (p *QBluetoothHostInfo) SetPointer(ptr unsafe.Pointer) {
p.ptr = ptr
}
func PointerFromQBluetoothHostInfo(ptr QBluetoothHostInfoITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothHostInfoPTR().Pointer()
}
return nil
}
func QBluetoothHostInfoFromPointer(ptr unsafe.Pointer) *QBluetoothHostInfo {
var n = new(QBluetoothHostInfo)
n.SetPointer(ptr)
return n
}
func (ptr *QBluetoothHostInfo) QBluetoothHostInfoPTR() *QBluetoothHostInfo {
return ptr
}
func NewQBluetoothHostInfo() *QBluetoothHostInfo {
return QBluetoothHostInfoFromPointer(unsafe.Pointer(C.QBluetoothHostInfo_NewQBluetoothHostInfo()))
}
func NewQBluetoothHostInfo2(other QBluetoothHostInfoITF) *QBluetoothHostInfo {
return QBluetoothHostInfoFromPointer(unsafe.Pointer(C.QBluetoothHostInfo_NewQBluetoothHostInfo2(C.QtObjectPtr(PointerFromQBluetoothHostInfo(other)))))
}
func (ptr *QBluetoothHostInfo) Name() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothHostInfo_Name(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothHostInfo) SetAddress(address QBluetoothAddressITF) {
if ptr.Pointer() != nil {
C.QBluetoothHostInfo_SetAddress(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothAddress(address)))
}
}
func (ptr *QBluetoothHostInfo) SetName(name string) {
if ptr.Pointer() != nil {
C.QBluetoothHostInfo_SetName(C.QtObjectPtr(ptr.Pointer()), C.CString(name))
}
}
func (ptr *QBluetoothHostInfo) DestroyQBluetoothHostInfo() {
if ptr.Pointer() != nil {
C.QBluetoothHostInfo_DestroyQBluetoothHostInfo(C.QtObjectPtr(ptr.Pointer()))
}
}

15
bluetooth/qbluetoothhostinfo.h Executable file
View file

@ -0,0 +1,15 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QBluetoothHostInfo_NewQBluetoothHostInfo();
QtObjectPtr QBluetoothHostInfo_NewQBluetoothHostInfo2(QtObjectPtr other);
char* QBluetoothHostInfo_Name(QtObjectPtr ptr);
void QBluetoothHostInfo_SetAddress(QtObjectPtr ptr, QtObjectPtr address);
void QBluetoothHostInfo_SetName(QtObjectPtr ptr, char* name);
void QBluetoothHostInfo_DestroyQBluetoothHostInfo(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

77
bluetooth/qbluetoothlocaldevice.cpp Executable file
View file

@ -0,0 +1,77 @@
#include "qbluetoothlocaldevice.h"
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QBluetoothAddress>
#include <QMetaObject>
#include <QObject>
#include <QBluetoothLocalDevice>
#include "_cgo_export.h"
class MyQBluetoothLocalDevice: public QBluetoothLocalDevice {
public:
void Signal_Error(QBluetoothLocalDevice::Error error){callbackQBluetoothLocalDeviceError(this->objectName().toUtf8().data(), error);};
void Signal_HostModeStateChanged(QBluetoothLocalDevice::HostMode state){callbackQBluetoothLocalDeviceHostModeStateChanged(this->objectName().toUtf8().data(), state);};
};
void QBluetoothLocalDevice_ConnectError(QtObjectPtr ptr){
QObject::connect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(QBluetoothLocalDevice::Error)>(&QBluetoothLocalDevice::error), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(QBluetoothLocalDevice::Error)>(&MyQBluetoothLocalDevice::Signal_Error));;
}
void QBluetoothLocalDevice_DisconnectError(QtObjectPtr ptr){
QObject::disconnect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(QBluetoothLocalDevice::Error)>(&QBluetoothLocalDevice::error), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(QBluetoothLocalDevice::Error)>(&MyQBluetoothLocalDevice::Signal_Error));;
}
void QBluetoothLocalDevice_ConnectHostModeStateChanged(QtObjectPtr ptr){
QObject::connect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(QBluetoothLocalDevice::HostMode)>(&QBluetoothLocalDevice::hostModeStateChanged), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(QBluetoothLocalDevice::HostMode)>(&MyQBluetoothLocalDevice::Signal_HostModeStateChanged));;
}
void QBluetoothLocalDevice_DisconnectHostModeStateChanged(QtObjectPtr ptr){
QObject::disconnect(static_cast<QBluetoothLocalDevice*>(ptr), static_cast<void (QBluetoothLocalDevice::*)(QBluetoothLocalDevice::HostMode)>(&QBluetoothLocalDevice::hostModeStateChanged), static_cast<MyQBluetoothLocalDevice*>(ptr), static_cast<void (MyQBluetoothLocalDevice::*)(QBluetoothLocalDevice::HostMode)>(&MyQBluetoothLocalDevice::Signal_HostModeStateChanged));;
}
int QBluetoothLocalDevice_IsValid(QtObjectPtr ptr){
return static_cast<QBluetoothLocalDevice*>(ptr)->isValid();
}
void QBluetoothLocalDevice_DestroyQBluetoothLocalDevice(QtObjectPtr ptr){
static_cast<QBluetoothLocalDevice*>(ptr)->~QBluetoothLocalDevice();
}
QtObjectPtr QBluetoothLocalDevice_NewQBluetoothLocalDevice(QtObjectPtr parent){
return new QBluetoothLocalDevice(static_cast<QObject*>(parent));
}
QtObjectPtr QBluetoothLocalDevice_NewQBluetoothLocalDevice2(QtObjectPtr address, QtObjectPtr parent){
return new QBluetoothLocalDevice(*static_cast<QBluetoothAddress*>(address), static_cast<QObject*>(parent));
}
int QBluetoothLocalDevice_HostMode(QtObjectPtr ptr){
return static_cast<QBluetoothLocalDevice*>(ptr)->hostMode();
}
char* QBluetoothLocalDevice_Name(QtObjectPtr ptr){
return static_cast<QBluetoothLocalDevice*>(ptr)->name().toUtf8().data();
}
void QBluetoothLocalDevice_PairingConfirmation(QtObjectPtr ptr, int accept){
QMetaObject::invokeMethod(static_cast<QBluetoothLocalDevice*>(ptr), "pairingConfirmation", Q_ARG(bool, accept != 0));
}
int QBluetoothLocalDevice_PairingStatus(QtObjectPtr ptr, QtObjectPtr address){
return static_cast<QBluetoothLocalDevice*>(ptr)->pairingStatus(*static_cast<QBluetoothAddress*>(address));
}
void QBluetoothLocalDevice_PowerOn(QtObjectPtr ptr){
static_cast<QBluetoothLocalDevice*>(ptr)->powerOn();
}
void QBluetoothLocalDevice_RequestPairing(QtObjectPtr ptr, QtObjectPtr address, int pairing){
static_cast<QBluetoothLocalDevice*>(ptr)->requestPairing(*static_cast<QBluetoothAddress*>(address), static_cast<QBluetoothLocalDevice::Pairing>(pairing));
}
void QBluetoothLocalDevice_SetHostMode(QtObjectPtr ptr, int mode){
static_cast<QBluetoothLocalDevice*>(ptr)->setHostMode(static_cast<QBluetoothLocalDevice::HostMode>(mode));
}

171
bluetooth/qbluetoothlocaldevice.go Executable file
View file

@ -0,0 +1,171 @@
package bluetooth
//#include "qbluetoothlocaldevice.h"
import "C"
import (
"github.com/therecipe/qt"
"github.com/therecipe/qt/core"
"unsafe"
)
type QBluetoothLocalDevice struct {
core.QObject
}
type QBluetoothLocalDeviceITF interface {
core.QObjectITF
QBluetoothLocalDevicePTR() *QBluetoothLocalDevice
}
func PointerFromQBluetoothLocalDevice(ptr QBluetoothLocalDeviceITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothLocalDevicePTR().Pointer()
}
return nil
}
func QBluetoothLocalDeviceFromPointer(ptr unsafe.Pointer) *QBluetoothLocalDevice {
var n = new(QBluetoothLocalDevice)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QBluetoothLocalDevice_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QBluetoothLocalDevice) QBluetoothLocalDevicePTR() *QBluetoothLocalDevice {
return ptr
}
//QBluetoothLocalDevice::Error
type QBluetoothLocalDevice__Error int
var (
QBluetoothLocalDevice__NoError = QBluetoothLocalDevice__Error(0)
QBluetoothLocalDevice__PairingError = QBluetoothLocalDevice__Error(1)
QBluetoothLocalDevice__UnknownError = QBluetoothLocalDevice__Error(100)
)
//QBluetoothLocalDevice::HostMode
type QBluetoothLocalDevice__HostMode int
var (
QBluetoothLocalDevice__HostPoweredOff = QBluetoothLocalDevice__HostMode(0)
QBluetoothLocalDevice__HostConnectable = QBluetoothLocalDevice__HostMode(1)
QBluetoothLocalDevice__HostDiscoverable = QBluetoothLocalDevice__HostMode(2)
QBluetoothLocalDevice__HostDiscoverableLimitedInquiry = QBluetoothLocalDevice__HostMode(3)
)
//QBluetoothLocalDevice::Pairing
type QBluetoothLocalDevice__Pairing int
var (
QBluetoothLocalDevice__Unpaired = QBluetoothLocalDevice__Pairing(0)
QBluetoothLocalDevice__Paired = QBluetoothLocalDevice__Pairing(1)
QBluetoothLocalDevice__AuthorizedPaired = QBluetoothLocalDevice__Pairing(2)
)
func (ptr *QBluetoothLocalDevice) ConnectError(f func(error QBluetoothLocalDevice__Error)) {
if ptr.Pointer() != nil {
C.QBluetoothLocalDevice_ConnectError(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "error", f)
}
}
func (ptr *QBluetoothLocalDevice) DisconnectError() {
if ptr.Pointer() != nil {
C.QBluetoothLocalDevice_DisconnectError(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "error")
}
}
//export callbackQBluetoothLocalDeviceError
func callbackQBluetoothLocalDeviceError(ptrName *C.char, error C.int) {
qt.GetSignal(C.GoString(ptrName), "error").(func(QBluetoothLocalDevice__Error))(QBluetoothLocalDevice__Error(error))
}
func (ptr *QBluetoothLocalDevice) ConnectHostModeStateChanged(f func(state QBluetoothLocalDevice__HostMode)) {
if ptr.Pointer() != nil {
C.QBluetoothLocalDevice_ConnectHostModeStateChanged(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "hostModeStateChanged", f)
}
}
func (ptr *QBluetoothLocalDevice) DisconnectHostModeStateChanged() {
if ptr.Pointer() != nil {
C.QBluetoothLocalDevice_DisconnectHostModeStateChanged(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "hostModeStateChanged")
}
}
//export callbackQBluetoothLocalDeviceHostModeStateChanged
func callbackQBluetoothLocalDeviceHostModeStateChanged(ptrName *C.char, state C.int) {
qt.GetSignal(C.GoString(ptrName), "hostModeStateChanged").(func(QBluetoothLocalDevice__HostMode))(QBluetoothLocalDevice__HostMode(state))
}
func (ptr *QBluetoothLocalDevice) IsValid() bool {
if ptr.Pointer() != nil {
return C.QBluetoothLocalDevice_IsValid(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothLocalDevice) DestroyQBluetoothLocalDevice() {
if ptr.Pointer() != nil {
C.QBluetoothLocalDevice_DestroyQBluetoothLocalDevice(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}
func NewQBluetoothLocalDevice(parent core.QObjectITF) *QBluetoothLocalDevice {
return QBluetoothLocalDeviceFromPointer(unsafe.Pointer(C.QBluetoothLocalDevice_NewQBluetoothLocalDevice(C.QtObjectPtr(core.PointerFromQObject(parent)))))
}
func NewQBluetoothLocalDevice2(address QBluetoothAddressITF, parent core.QObjectITF) *QBluetoothLocalDevice {
return QBluetoothLocalDeviceFromPointer(unsafe.Pointer(C.QBluetoothLocalDevice_NewQBluetoothLocalDevice2(C.QtObjectPtr(PointerFromQBluetoothAddress(address)), C.QtObjectPtr(core.PointerFromQObject(parent)))))
}
func (ptr *QBluetoothLocalDevice) HostMode() QBluetoothLocalDevice__HostMode {
if ptr.Pointer() != nil {
return QBluetoothLocalDevice__HostMode(C.QBluetoothLocalDevice_HostMode(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothLocalDevice) Name() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothLocalDevice_Name(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothLocalDevice) PairingConfirmation(accept bool) {
if ptr.Pointer() != nil {
C.QBluetoothLocalDevice_PairingConfirmation(C.QtObjectPtr(ptr.Pointer()), C.int(qt.GoBoolToInt(accept)))
}
}
func (ptr *QBluetoothLocalDevice) PairingStatus(address QBluetoothAddressITF) QBluetoothLocalDevice__Pairing {
if ptr.Pointer() != nil {
return QBluetoothLocalDevice__Pairing(C.QBluetoothLocalDevice_PairingStatus(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothAddress(address))))
}
return 0
}
func (ptr *QBluetoothLocalDevice) PowerOn() {
if ptr.Pointer() != nil {
C.QBluetoothLocalDevice_PowerOn(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QBluetoothLocalDevice) RequestPairing(address QBluetoothAddressITF, pairing QBluetoothLocalDevice__Pairing) {
if ptr.Pointer() != nil {
C.QBluetoothLocalDevice_RequestPairing(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothAddress(address)), C.int(pairing))
}
}
func (ptr *QBluetoothLocalDevice) SetHostMode(mode QBluetoothLocalDevice__HostMode) {
if ptr.Pointer() != nil {
C.QBluetoothLocalDevice_SetHostMode(C.QtObjectPtr(ptr.Pointer()), C.int(mode))
}
}

24
bluetooth/qbluetoothlocaldevice.h Executable file
View file

@ -0,0 +1,24 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
void QBluetoothLocalDevice_ConnectError(QtObjectPtr ptr);
void QBluetoothLocalDevice_DisconnectError(QtObjectPtr ptr);
void QBluetoothLocalDevice_ConnectHostModeStateChanged(QtObjectPtr ptr);
void QBluetoothLocalDevice_DisconnectHostModeStateChanged(QtObjectPtr ptr);
int QBluetoothLocalDevice_IsValid(QtObjectPtr ptr);
void QBluetoothLocalDevice_DestroyQBluetoothLocalDevice(QtObjectPtr ptr);
QtObjectPtr QBluetoothLocalDevice_NewQBluetoothLocalDevice(QtObjectPtr parent);
QtObjectPtr QBluetoothLocalDevice_NewQBluetoothLocalDevice2(QtObjectPtr address, QtObjectPtr parent);
int QBluetoothLocalDevice_HostMode(QtObjectPtr ptr);
char* QBluetoothLocalDevice_Name(QtObjectPtr ptr);
void QBluetoothLocalDevice_PairingConfirmation(QtObjectPtr ptr, int accept);
int QBluetoothLocalDevice_PairingStatus(QtObjectPtr ptr, QtObjectPtr address);
void QBluetoothLocalDevice_PowerOn(QtObjectPtr ptr);
void QBluetoothLocalDevice_RequestPairing(QtObjectPtr ptr, QtObjectPtr address, int pairing);
void QBluetoothLocalDevice_SetHostMode(QtObjectPtr ptr, int mode);
#ifdef __cplusplus
}
#endif

63
bluetooth/qbluetoothserver.cpp Executable file
View file

@ -0,0 +1,63 @@
#include "qbluetoothserver.h"
#include <QObject>
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QBluetoothServiceInfo>
#include <QBluetoothServer>
#include "_cgo_export.h"
class MyQBluetoothServer: public QBluetoothServer {
public:
void Signal_NewConnection(){callbackQBluetoothServerNewConnection(this->objectName().toUtf8().data());};
};
QtObjectPtr QBluetoothServer_NewQBluetoothServer(int serverType, QtObjectPtr parent){
return new QBluetoothServer(static_cast<QBluetoothServiceInfo::Protocol>(serverType), static_cast<QObject*>(parent));
}
void QBluetoothServer_ConnectNewConnection(QtObjectPtr ptr){
QObject::connect(static_cast<QBluetoothServer*>(ptr), static_cast<void (QBluetoothServer::*)()>(&QBluetoothServer::newConnection), static_cast<MyQBluetoothServer*>(ptr), static_cast<void (MyQBluetoothServer::*)()>(&MyQBluetoothServer::Signal_NewConnection));;
}
void QBluetoothServer_DisconnectNewConnection(QtObjectPtr ptr){
QObject::disconnect(static_cast<QBluetoothServer*>(ptr), static_cast<void (QBluetoothServer::*)()>(&QBluetoothServer::newConnection), static_cast<MyQBluetoothServer*>(ptr), static_cast<void (MyQBluetoothServer::*)()>(&MyQBluetoothServer::Signal_NewConnection));;
}
int QBluetoothServer_Error(QtObjectPtr ptr){
return static_cast<QBluetoothServer*>(ptr)->error();
}
int QBluetoothServer_IsListening(QtObjectPtr ptr){
return static_cast<QBluetoothServer*>(ptr)->isListening();
}
int QBluetoothServer_MaxPendingConnections(QtObjectPtr ptr){
return static_cast<QBluetoothServer*>(ptr)->maxPendingConnections();
}
int QBluetoothServer_ServerType(QtObjectPtr ptr){
return static_cast<QBluetoothServer*>(ptr)->serverType();
}
void QBluetoothServer_DestroyQBluetoothServer(QtObjectPtr ptr){
static_cast<QBluetoothServer*>(ptr)->~QBluetoothServer();
}
void QBluetoothServer_Close(QtObjectPtr ptr){
static_cast<QBluetoothServer*>(ptr)->close();
}
int QBluetoothServer_HasPendingConnections(QtObjectPtr ptr){
return static_cast<QBluetoothServer*>(ptr)->hasPendingConnections();
}
QtObjectPtr QBluetoothServer_NextPendingConnection(QtObjectPtr ptr){
return static_cast<QBluetoothServer*>(ptr)->nextPendingConnection();
}
void QBluetoothServer_SetMaxPendingConnections(QtObjectPtr ptr, int numConnections){
static_cast<QBluetoothServer*>(ptr)->setMaxPendingConnections(numConnections);
}

134
bluetooth/qbluetoothserver.go Executable file
View file

@ -0,0 +1,134 @@
package bluetooth
//#include "qbluetoothserver.h"
import "C"
import (
"github.com/therecipe/qt"
"github.com/therecipe/qt/core"
"unsafe"
)
type QBluetoothServer struct {
core.QObject
}
type QBluetoothServerITF interface {
core.QObjectITF
QBluetoothServerPTR() *QBluetoothServer
}
func PointerFromQBluetoothServer(ptr QBluetoothServerITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothServerPTR().Pointer()
}
return nil
}
func QBluetoothServerFromPointer(ptr unsafe.Pointer) *QBluetoothServer {
var n = new(QBluetoothServer)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QBluetoothServer_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QBluetoothServer) QBluetoothServerPTR() *QBluetoothServer {
return ptr
}
//QBluetoothServer::Error
type QBluetoothServer__Error int
var (
QBluetoothServer__NoError = QBluetoothServer__Error(0)
QBluetoothServer__UnknownError = QBluetoothServer__Error(1)
QBluetoothServer__PoweredOffError = QBluetoothServer__Error(2)
QBluetoothServer__InputOutputError = QBluetoothServer__Error(3)
QBluetoothServer__ServiceAlreadyRegisteredError = QBluetoothServer__Error(4)
QBluetoothServer__UnsupportedProtocolError = QBluetoothServer__Error(5)
)
func NewQBluetoothServer(serverType QBluetoothServiceInfo__Protocol, parent core.QObjectITF) *QBluetoothServer {
return QBluetoothServerFromPointer(unsafe.Pointer(C.QBluetoothServer_NewQBluetoothServer(C.int(serverType), C.QtObjectPtr(core.PointerFromQObject(parent)))))
}
func (ptr *QBluetoothServer) ConnectNewConnection(f func()) {
if ptr.Pointer() != nil {
C.QBluetoothServer_ConnectNewConnection(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "newConnection", f)
}
}
func (ptr *QBluetoothServer) DisconnectNewConnection() {
if ptr.Pointer() != nil {
C.QBluetoothServer_DisconnectNewConnection(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "newConnection")
}
}
//export callbackQBluetoothServerNewConnection
func callbackQBluetoothServerNewConnection(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "newConnection").(func())()
}
func (ptr *QBluetoothServer) Error() QBluetoothServer__Error {
if ptr.Pointer() != nil {
return QBluetoothServer__Error(C.QBluetoothServer_Error(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothServer) IsListening() bool {
if ptr.Pointer() != nil {
return C.QBluetoothServer_IsListening(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothServer) MaxPendingConnections() int {
if ptr.Pointer() != nil {
return int(C.QBluetoothServer_MaxPendingConnections(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothServer) ServerType() QBluetoothServiceInfo__Protocol {
if ptr.Pointer() != nil {
return QBluetoothServiceInfo__Protocol(C.QBluetoothServer_ServerType(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothServer) DestroyQBluetoothServer() {
if ptr.Pointer() != nil {
C.QBluetoothServer_DestroyQBluetoothServer(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}
func (ptr *QBluetoothServer) Close() {
if ptr.Pointer() != nil {
C.QBluetoothServer_Close(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QBluetoothServer) HasPendingConnections() bool {
if ptr.Pointer() != nil {
return C.QBluetoothServer_HasPendingConnections(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothServer) NextPendingConnection() *QBluetoothSocket {
if ptr.Pointer() != nil {
return QBluetoothSocketFromPointer(unsafe.Pointer(C.QBluetoothServer_NextPendingConnection(C.QtObjectPtr(ptr.Pointer()))))
}
return nil
}
func (ptr *QBluetoothServer) SetMaxPendingConnections(numConnections int) {
if ptr.Pointer() != nil {
C.QBluetoothServer_SetMaxPendingConnections(C.QtObjectPtr(ptr.Pointer()), C.int(numConnections))
}
}

21
bluetooth/qbluetoothserver.h Executable file
View file

@ -0,0 +1,21 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QBluetoothServer_NewQBluetoothServer(int serverType, QtObjectPtr parent);
void QBluetoothServer_ConnectNewConnection(QtObjectPtr ptr);
void QBluetoothServer_DisconnectNewConnection(QtObjectPtr ptr);
int QBluetoothServer_Error(QtObjectPtr ptr);
int QBluetoothServer_IsListening(QtObjectPtr ptr);
int QBluetoothServer_MaxPendingConnections(QtObjectPtr ptr);
int QBluetoothServer_ServerType(QtObjectPtr ptr);
void QBluetoothServer_DestroyQBluetoothServer(QtObjectPtr ptr);
void QBluetoothServer_Close(QtObjectPtr ptr);
int QBluetoothServer_HasPendingConnections(QtObjectPtr ptr);
QtObjectPtr QBluetoothServer_NextPendingConnection(QtObjectPtr ptr);
void QBluetoothServer_SetMaxPendingConnections(QtObjectPtr ptr, int numConnections);
#ifdef __cplusplus
}
#endif

78
bluetooth/qbluetoothservicediscoveryagent.cpp Executable file
View file

@ -0,0 +1,78 @@
#include "qbluetoothservicediscoveryagent.h"
#include <QObject>
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QBluetoothAddress>
#include <QBluetoothUuid>
#include <QMetaObject>
#include <QBluetoothServiceDiscoveryAgent>
#include "_cgo_export.h"
class MyQBluetoothServiceDiscoveryAgent: public QBluetoothServiceDiscoveryAgent {
public:
void Signal_Canceled(){callbackQBluetoothServiceDiscoveryAgentCanceled(this->objectName().toUtf8().data());};
void Signal_Finished(){callbackQBluetoothServiceDiscoveryAgentFinished(this->objectName().toUtf8().data());};
};
void QBluetoothServiceDiscoveryAgent_ConnectCanceled(QtObjectPtr ptr){
QObject::connect(static_cast<QBluetoothServiceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothServiceDiscoveryAgent::*)()>(&QBluetoothServiceDiscoveryAgent::canceled), static_cast<MyQBluetoothServiceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothServiceDiscoveryAgent::*)()>(&MyQBluetoothServiceDiscoveryAgent::Signal_Canceled));;
}
void QBluetoothServiceDiscoveryAgent_DisconnectCanceled(QtObjectPtr ptr){
QObject::disconnect(static_cast<QBluetoothServiceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothServiceDiscoveryAgent::*)()>(&QBluetoothServiceDiscoveryAgent::canceled), static_cast<MyQBluetoothServiceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothServiceDiscoveryAgent::*)()>(&MyQBluetoothServiceDiscoveryAgent::Signal_Canceled));;
}
void QBluetoothServiceDiscoveryAgent_ConnectFinished(QtObjectPtr ptr){
QObject::connect(static_cast<QBluetoothServiceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothServiceDiscoveryAgent::*)()>(&QBluetoothServiceDiscoveryAgent::finished), static_cast<MyQBluetoothServiceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothServiceDiscoveryAgent::*)()>(&MyQBluetoothServiceDiscoveryAgent::Signal_Finished));;
}
void QBluetoothServiceDiscoveryAgent_DisconnectFinished(QtObjectPtr ptr){
QObject::disconnect(static_cast<QBluetoothServiceDiscoveryAgent*>(ptr), static_cast<void (QBluetoothServiceDiscoveryAgent::*)()>(&QBluetoothServiceDiscoveryAgent::finished), static_cast<MyQBluetoothServiceDiscoveryAgent*>(ptr), static_cast<void (MyQBluetoothServiceDiscoveryAgent::*)()>(&MyQBluetoothServiceDiscoveryAgent::Signal_Finished));;
}
QtObjectPtr QBluetoothServiceDiscoveryAgent_NewQBluetoothServiceDiscoveryAgent(QtObjectPtr parent){
return new QBluetoothServiceDiscoveryAgent(static_cast<QObject*>(parent));
}
QtObjectPtr QBluetoothServiceDiscoveryAgent_NewQBluetoothServiceDiscoveryAgent2(QtObjectPtr deviceAdapter, QtObjectPtr parent){
return new QBluetoothServiceDiscoveryAgent(*static_cast<QBluetoothAddress*>(deviceAdapter), static_cast<QObject*>(parent));
}
void QBluetoothServiceDiscoveryAgent_Clear(QtObjectPtr ptr){
QMetaObject::invokeMethod(static_cast<QBluetoothServiceDiscoveryAgent*>(ptr), "clear");
}
int QBluetoothServiceDiscoveryAgent_Error(QtObjectPtr ptr){
return static_cast<QBluetoothServiceDiscoveryAgent*>(ptr)->error();
}
char* QBluetoothServiceDiscoveryAgent_ErrorString(QtObjectPtr ptr){
return static_cast<QBluetoothServiceDiscoveryAgent*>(ptr)->errorString().toUtf8().data();
}
int QBluetoothServiceDiscoveryAgent_IsActive(QtObjectPtr ptr){
return static_cast<QBluetoothServiceDiscoveryAgent*>(ptr)->isActive();
}
int QBluetoothServiceDiscoveryAgent_SetRemoteAddress(QtObjectPtr ptr, QtObjectPtr address){
return static_cast<QBluetoothServiceDiscoveryAgent*>(ptr)->setRemoteAddress(*static_cast<QBluetoothAddress*>(address));
}
void QBluetoothServiceDiscoveryAgent_SetUuidFilter2(QtObjectPtr ptr, QtObjectPtr uuid){
static_cast<QBluetoothServiceDiscoveryAgent*>(ptr)->setUuidFilter(*static_cast<QBluetoothUuid*>(uuid));
}
void QBluetoothServiceDiscoveryAgent_Start(QtObjectPtr ptr, int mode){
QMetaObject::invokeMethod(static_cast<QBluetoothServiceDiscoveryAgent*>(ptr), "start", Q_ARG(QBluetoothServiceDiscoveryAgent::DiscoveryMode, static_cast<QBluetoothServiceDiscoveryAgent::DiscoveryMode>(mode)));
}
void QBluetoothServiceDiscoveryAgent_Stop(QtObjectPtr ptr){
QMetaObject::invokeMethod(static_cast<QBluetoothServiceDiscoveryAgent*>(ptr), "stop");
}
void QBluetoothServiceDiscoveryAgent_DestroyQBluetoothServiceDiscoveryAgent(QtObjectPtr ptr){
static_cast<QBluetoothServiceDiscoveryAgent*>(ptr)->~QBluetoothServiceDiscoveryAgent();
}

162
bluetooth/qbluetoothservicediscoveryagent.go Executable file
View file

@ -0,0 +1,162 @@
package bluetooth
//#include "qbluetoothservicediscoveryagent.h"
import "C"
import (
"github.com/therecipe/qt"
"github.com/therecipe/qt/core"
"unsafe"
)
type QBluetoothServiceDiscoveryAgent struct {
core.QObject
}
type QBluetoothServiceDiscoveryAgentITF interface {
core.QObjectITF
QBluetoothServiceDiscoveryAgentPTR() *QBluetoothServiceDiscoveryAgent
}
func PointerFromQBluetoothServiceDiscoveryAgent(ptr QBluetoothServiceDiscoveryAgentITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothServiceDiscoveryAgentPTR().Pointer()
}
return nil
}
func QBluetoothServiceDiscoveryAgentFromPointer(ptr unsafe.Pointer) *QBluetoothServiceDiscoveryAgent {
var n = new(QBluetoothServiceDiscoveryAgent)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QBluetoothServiceDiscoveryAgent_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QBluetoothServiceDiscoveryAgent) QBluetoothServiceDiscoveryAgentPTR() *QBluetoothServiceDiscoveryAgent {
return ptr
}
//QBluetoothServiceDiscoveryAgent::DiscoveryMode
type QBluetoothServiceDiscoveryAgent__DiscoveryMode int
var (
QBluetoothServiceDiscoveryAgent__MinimalDiscovery = QBluetoothServiceDiscoveryAgent__DiscoveryMode(0)
QBluetoothServiceDiscoveryAgent__FullDiscovery = QBluetoothServiceDiscoveryAgent__DiscoveryMode(1)
)
//QBluetoothServiceDiscoveryAgent::Error
type QBluetoothServiceDiscoveryAgent__Error int
var (
QBluetoothServiceDiscoveryAgent__NoError = QBluetoothServiceDiscoveryAgent__Error(QBluetoothDeviceDiscoveryAgent__NoError)
QBluetoothServiceDiscoveryAgent__InputOutputError = QBluetoothServiceDiscoveryAgent__Error(QBluetoothDeviceDiscoveryAgent__InputOutputError)
QBluetoothServiceDiscoveryAgent__PoweredOffError = QBluetoothServiceDiscoveryAgent__Error(QBluetoothDeviceDiscoveryAgent__PoweredOffError)
QBluetoothServiceDiscoveryAgent__InvalidBluetoothAdapterError = QBluetoothServiceDiscoveryAgent__Error(QBluetoothDeviceDiscoveryAgent__InvalidBluetoothAdapterError)
QBluetoothServiceDiscoveryAgent__UnknownError = QBluetoothServiceDiscoveryAgent__Error(QBluetoothDeviceDiscoveryAgent__UnknownError)
)
func (ptr *QBluetoothServiceDiscoveryAgent) ConnectCanceled(f func()) {
if ptr.Pointer() != nil {
C.QBluetoothServiceDiscoveryAgent_ConnectCanceled(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "canceled", f)
}
}
func (ptr *QBluetoothServiceDiscoveryAgent) DisconnectCanceled() {
if ptr.Pointer() != nil {
C.QBluetoothServiceDiscoveryAgent_DisconnectCanceled(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "canceled")
}
}
//export callbackQBluetoothServiceDiscoveryAgentCanceled
func callbackQBluetoothServiceDiscoveryAgentCanceled(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "canceled").(func())()
}
func (ptr *QBluetoothServiceDiscoveryAgent) ConnectFinished(f func()) {
if ptr.Pointer() != nil {
C.QBluetoothServiceDiscoveryAgent_ConnectFinished(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "finished", f)
}
}
func (ptr *QBluetoothServiceDiscoveryAgent) DisconnectFinished() {
if ptr.Pointer() != nil {
C.QBluetoothServiceDiscoveryAgent_DisconnectFinished(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "finished")
}
}
//export callbackQBluetoothServiceDiscoveryAgentFinished
func callbackQBluetoothServiceDiscoveryAgentFinished(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "finished").(func())()
}
func NewQBluetoothServiceDiscoveryAgent(parent core.QObjectITF) *QBluetoothServiceDiscoveryAgent {
return QBluetoothServiceDiscoveryAgentFromPointer(unsafe.Pointer(C.QBluetoothServiceDiscoveryAgent_NewQBluetoothServiceDiscoveryAgent(C.QtObjectPtr(core.PointerFromQObject(parent)))))
}
func NewQBluetoothServiceDiscoveryAgent2(deviceAdapter QBluetoothAddressITF, parent core.QObjectITF) *QBluetoothServiceDiscoveryAgent {
return QBluetoothServiceDiscoveryAgentFromPointer(unsafe.Pointer(C.QBluetoothServiceDiscoveryAgent_NewQBluetoothServiceDiscoveryAgent2(C.QtObjectPtr(PointerFromQBluetoothAddress(deviceAdapter)), C.QtObjectPtr(core.PointerFromQObject(parent)))))
}
func (ptr *QBluetoothServiceDiscoveryAgent) Clear() {
if ptr.Pointer() != nil {
C.QBluetoothServiceDiscoveryAgent_Clear(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QBluetoothServiceDiscoveryAgent) Error() QBluetoothServiceDiscoveryAgent__Error {
if ptr.Pointer() != nil {
return QBluetoothServiceDiscoveryAgent__Error(C.QBluetoothServiceDiscoveryAgent_Error(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothServiceDiscoveryAgent) ErrorString() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothServiceDiscoveryAgent_ErrorString(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothServiceDiscoveryAgent) IsActive() bool {
if ptr.Pointer() != nil {
return C.QBluetoothServiceDiscoveryAgent_IsActive(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothServiceDiscoveryAgent) SetRemoteAddress(address QBluetoothAddressITF) bool {
if ptr.Pointer() != nil {
return C.QBluetoothServiceDiscoveryAgent_SetRemoteAddress(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothAddress(address))) != 0
}
return false
}
func (ptr *QBluetoothServiceDiscoveryAgent) SetUuidFilter2(uuid QBluetoothUuidITF) {
if ptr.Pointer() != nil {
C.QBluetoothServiceDiscoveryAgent_SetUuidFilter2(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothUuid(uuid)))
}
}
func (ptr *QBluetoothServiceDiscoveryAgent) Start(mode QBluetoothServiceDiscoveryAgent__DiscoveryMode) {
if ptr.Pointer() != nil {
C.QBluetoothServiceDiscoveryAgent_Start(C.QtObjectPtr(ptr.Pointer()), C.int(mode))
}
}
func (ptr *QBluetoothServiceDiscoveryAgent) Stop() {
if ptr.Pointer() != nil {
C.QBluetoothServiceDiscoveryAgent_Stop(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QBluetoothServiceDiscoveryAgent) DestroyQBluetoothServiceDiscoveryAgent() {
if ptr.Pointer() != nil {
C.QBluetoothServiceDiscoveryAgent_DestroyQBluetoothServiceDiscoveryAgent(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

24
bluetooth/qbluetoothservicediscoveryagent.h Executable file
View file

@ -0,0 +1,24 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
void QBluetoothServiceDiscoveryAgent_ConnectCanceled(QtObjectPtr ptr);
void QBluetoothServiceDiscoveryAgent_DisconnectCanceled(QtObjectPtr ptr);
void QBluetoothServiceDiscoveryAgent_ConnectFinished(QtObjectPtr ptr);
void QBluetoothServiceDiscoveryAgent_DisconnectFinished(QtObjectPtr ptr);
QtObjectPtr QBluetoothServiceDiscoveryAgent_NewQBluetoothServiceDiscoveryAgent(QtObjectPtr parent);
QtObjectPtr QBluetoothServiceDiscoveryAgent_NewQBluetoothServiceDiscoveryAgent2(QtObjectPtr deviceAdapter, QtObjectPtr parent);
void QBluetoothServiceDiscoveryAgent_Clear(QtObjectPtr ptr);
int QBluetoothServiceDiscoveryAgent_Error(QtObjectPtr ptr);
char* QBluetoothServiceDiscoveryAgent_ErrorString(QtObjectPtr ptr);
int QBluetoothServiceDiscoveryAgent_IsActive(QtObjectPtr ptr);
int QBluetoothServiceDiscoveryAgent_SetRemoteAddress(QtObjectPtr ptr, QtObjectPtr address);
void QBluetoothServiceDiscoveryAgent_SetUuidFilter2(QtObjectPtr ptr, QtObjectPtr uuid);
void QBluetoothServiceDiscoveryAgent_Start(QtObjectPtr ptr, int mode);
void QBluetoothServiceDiscoveryAgent_Stop(QtObjectPtr ptr);
void QBluetoothServiceDiscoveryAgent_DestroyQBluetoothServiceDiscoveryAgent(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

103
bluetooth/qbluetoothserviceinfo.cpp Executable file
View file

@ -0,0 +1,103 @@
#include "qbluetoothserviceinfo.h"
#include <QBluetoothDeviceInfo>
#include <QBluetoothAddress>
#include <QBluetoothUuid>
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QBluetoothServiceInfo>
#include "_cgo_export.h"
class MyQBluetoothServiceInfo: public QBluetoothServiceInfo {
public:
};
int QBluetoothServiceInfo_ServiceName_Type(){
return QBluetoothServiceInfo::ServiceName;
}
int QBluetoothServiceInfo_ServiceDescription_Type(){
return QBluetoothServiceInfo::ServiceDescription;
}
int QBluetoothServiceInfo_ServiceProvider_Type(){
return QBluetoothServiceInfo::ServiceProvider;
}
char* QBluetoothServiceInfo_ServiceDescription(QtObjectPtr ptr){
return static_cast<QBluetoothServiceInfo*>(ptr)->serviceDescription().toUtf8().data();
}
char* QBluetoothServiceInfo_ServiceName(QtObjectPtr ptr){
return static_cast<QBluetoothServiceInfo*>(ptr)->serviceName().toUtf8().data();
}
char* QBluetoothServiceInfo_ServiceProvider(QtObjectPtr ptr){
return static_cast<QBluetoothServiceInfo*>(ptr)->serviceProvider().toUtf8().data();
}
void QBluetoothServiceInfo_SetServiceDescription(QtObjectPtr ptr, char* description){
static_cast<QBluetoothServiceInfo*>(ptr)->setServiceDescription(QString(description));
}
void QBluetoothServiceInfo_SetServiceName(QtObjectPtr ptr, char* name){
static_cast<QBluetoothServiceInfo*>(ptr)->setServiceName(QString(name));
}
void QBluetoothServiceInfo_SetServiceProvider(QtObjectPtr ptr, char* provider){
static_cast<QBluetoothServiceInfo*>(ptr)->setServiceProvider(QString(provider));
}
void QBluetoothServiceInfo_SetServiceUuid(QtObjectPtr ptr, QtObjectPtr uuid){
static_cast<QBluetoothServiceInfo*>(ptr)->setServiceUuid(*static_cast<QBluetoothUuid*>(uuid));
}
QtObjectPtr QBluetoothServiceInfo_NewQBluetoothServiceInfo(){
return new QBluetoothServiceInfo();
}
QtObjectPtr QBluetoothServiceInfo_NewQBluetoothServiceInfo2(QtObjectPtr other){
return new QBluetoothServiceInfo(*static_cast<QBluetoothServiceInfo*>(other));
}
int QBluetoothServiceInfo_IsComplete(QtObjectPtr ptr){
return static_cast<QBluetoothServiceInfo*>(ptr)->isComplete();
}
int QBluetoothServiceInfo_IsRegistered(QtObjectPtr ptr){
return static_cast<QBluetoothServiceInfo*>(ptr)->isRegistered();
}
int QBluetoothServiceInfo_IsValid(QtObjectPtr ptr){
return static_cast<QBluetoothServiceInfo*>(ptr)->isValid();
}
int QBluetoothServiceInfo_ProtocolServiceMultiplexer(QtObjectPtr ptr){
return static_cast<QBluetoothServiceInfo*>(ptr)->protocolServiceMultiplexer();
}
int QBluetoothServiceInfo_RegisterService(QtObjectPtr ptr, QtObjectPtr localAdapter){
return static_cast<QBluetoothServiceInfo*>(ptr)->registerService(*static_cast<QBluetoothAddress*>(localAdapter));
}
int QBluetoothServiceInfo_ServerChannel(QtObjectPtr ptr){
return static_cast<QBluetoothServiceInfo*>(ptr)->serverChannel();
}
void QBluetoothServiceInfo_SetDevice(QtObjectPtr ptr, QtObjectPtr device){
static_cast<QBluetoothServiceInfo*>(ptr)->setDevice(*static_cast<QBluetoothDeviceInfo*>(device));
}
int QBluetoothServiceInfo_SocketProtocol(QtObjectPtr ptr){
return static_cast<QBluetoothServiceInfo*>(ptr)->socketProtocol();
}
int QBluetoothServiceInfo_UnregisterService(QtObjectPtr ptr){
return static_cast<QBluetoothServiceInfo*>(ptr)->unregisterService();
}
void QBluetoothServiceInfo_DestroyQBluetoothServiceInfo(QtObjectPtr ptr){
static_cast<QBluetoothServiceInfo*>(ptr)->~QBluetoothServiceInfo();
}

194
bluetooth/qbluetoothserviceinfo.go Executable file
View file

@ -0,0 +1,194 @@
package bluetooth
//#include "qbluetoothserviceinfo.h"
import "C"
import (
"unsafe"
)
type QBluetoothServiceInfo struct {
ptr unsafe.Pointer
}
type QBluetoothServiceInfoITF interface {
QBluetoothServiceInfoPTR() *QBluetoothServiceInfo
}
func (p *QBluetoothServiceInfo) Pointer() unsafe.Pointer {
return p.ptr
}
func (p *QBluetoothServiceInfo) SetPointer(ptr unsafe.Pointer) {
p.ptr = ptr
}
func PointerFromQBluetoothServiceInfo(ptr QBluetoothServiceInfoITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothServiceInfoPTR().Pointer()
}
return nil
}
func QBluetoothServiceInfoFromPointer(ptr unsafe.Pointer) *QBluetoothServiceInfo {
var n = new(QBluetoothServiceInfo)
n.SetPointer(ptr)
return n
}
func (ptr *QBluetoothServiceInfo) QBluetoothServiceInfoPTR() *QBluetoothServiceInfo {
return ptr
}
//QBluetoothServiceInfo::AttributeId
type QBluetoothServiceInfo__AttributeId int
var (
QBluetoothServiceInfo__ServiceRecordHandle = QBluetoothServiceInfo__AttributeId(0x0000)
QBluetoothServiceInfo__ServiceClassIds = QBluetoothServiceInfo__AttributeId(0x0001)
QBluetoothServiceInfo__ServiceRecordState = QBluetoothServiceInfo__AttributeId(0x0002)
QBluetoothServiceInfo__ServiceId = QBluetoothServiceInfo__AttributeId(0x0003)
QBluetoothServiceInfo__ProtocolDescriptorList = QBluetoothServiceInfo__AttributeId(0x0004)
QBluetoothServiceInfo__BrowseGroupList = QBluetoothServiceInfo__AttributeId(0x0005)
QBluetoothServiceInfo__LanguageBaseAttributeIdList = QBluetoothServiceInfo__AttributeId(0x0006)
QBluetoothServiceInfo__ServiceInfoTimeToLive = QBluetoothServiceInfo__AttributeId(0x0007)
QBluetoothServiceInfo__ServiceAvailability = QBluetoothServiceInfo__AttributeId(0x0008)
QBluetoothServiceInfo__BluetoothProfileDescriptorList = QBluetoothServiceInfo__AttributeId(0x0009)
QBluetoothServiceInfo__DocumentationUrl = QBluetoothServiceInfo__AttributeId(0x000A)
QBluetoothServiceInfo__ClientExecutableUrl = QBluetoothServiceInfo__AttributeId(0x000B)
QBluetoothServiceInfo__IconUrl = QBluetoothServiceInfo__AttributeId(0x000C)
QBluetoothServiceInfo__AdditionalProtocolDescriptorList = QBluetoothServiceInfo__AttributeId(0x000D)
QBluetoothServiceInfo__PrimaryLanguageBase = QBluetoothServiceInfo__AttributeId(0x0100)
QBluetoothServiceInfo__ServiceName = QBluetoothServiceInfo__AttributeId(C.QBluetoothServiceInfo_ServiceName_Type())
QBluetoothServiceInfo__ServiceDescription = QBluetoothServiceInfo__AttributeId(C.QBluetoothServiceInfo_ServiceDescription_Type())
QBluetoothServiceInfo__ServiceProvider = QBluetoothServiceInfo__AttributeId(C.QBluetoothServiceInfo_ServiceProvider_Type())
)
//QBluetoothServiceInfo::Protocol
type QBluetoothServiceInfo__Protocol int
var (
QBluetoothServiceInfo__UnknownProtocol = QBluetoothServiceInfo__Protocol(0)
QBluetoothServiceInfo__L2capProtocol = QBluetoothServiceInfo__Protocol(1)
QBluetoothServiceInfo__RfcommProtocol = QBluetoothServiceInfo__Protocol(2)
)
func (ptr *QBluetoothServiceInfo) ServiceDescription() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothServiceInfo_ServiceDescription(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothServiceInfo) ServiceName() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothServiceInfo_ServiceName(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothServiceInfo) ServiceProvider() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothServiceInfo_ServiceProvider(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothServiceInfo) SetServiceDescription(description string) {
if ptr.Pointer() != nil {
C.QBluetoothServiceInfo_SetServiceDescription(C.QtObjectPtr(ptr.Pointer()), C.CString(description))
}
}
func (ptr *QBluetoothServiceInfo) SetServiceName(name string) {
if ptr.Pointer() != nil {
C.QBluetoothServiceInfo_SetServiceName(C.QtObjectPtr(ptr.Pointer()), C.CString(name))
}
}
func (ptr *QBluetoothServiceInfo) SetServiceProvider(provider string) {
if ptr.Pointer() != nil {
C.QBluetoothServiceInfo_SetServiceProvider(C.QtObjectPtr(ptr.Pointer()), C.CString(provider))
}
}
func (ptr *QBluetoothServiceInfo) SetServiceUuid(uuid QBluetoothUuidITF) {
if ptr.Pointer() != nil {
C.QBluetoothServiceInfo_SetServiceUuid(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothUuid(uuid)))
}
}
func NewQBluetoothServiceInfo() *QBluetoothServiceInfo {
return QBluetoothServiceInfoFromPointer(unsafe.Pointer(C.QBluetoothServiceInfo_NewQBluetoothServiceInfo()))
}
func NewQBluetoothServiceInfo2(other QBluetoothServiceInfoITF) *QBluetoothServiceInfo {
return QBluetoothServiceInfoFromPointer(unsafe.Pointer(C.QBluetoothServiceInfo_NewQBluetoothServiceInfo2(C.QtObjectPtr(PointerFromQBluetoothServiceInfo(other)))))
}
func (ptr *QBluetoothServiceInfo) IsComplete() bool {
if ptr.Pointer() != nil {
return C.QBluetoothServiceInfo_IsComplete(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothServiceInfo) IsRegistered() bool {
if ptr.Pointer() != nil {
return C.QBluetoothServiceInfo_IsRegistered(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothServiceInfo) IsValid() bool {
if ptr.Pointer() != nil {
return C.QBluetoothServiceInfo_IsValid(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothServiceInfo) ProtocolServiceMultiplexer() int {
if ptr.Pointer() != nil {
return int(C.QBluetoothServiceInfo_ProtocolServiceMultiplexer(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothServiceInfo) RegisterService(localAdapter QBluetoothAddressITF) bool {
if ptr.Pointer() != nil {
return C.QBluetoothServiceInfo_RegisterService(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothAddress(localAdapter))) != 0
}
return false
}
func (ptr *QBluetoothServiceInfo) ServerChannel() int {
if ptr.Pointer() != nil {
return int(C.QBluetoothServiceInfo_ServerChannel(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothServiceInfo) SetDevice(device QBluetoothDeviceInfoITF) {
if ptr.Pointer() != nil {
C.QBluetoothServiceInfo_SetDevice(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothDeviceInfo(device)))
}
}
func (ptr *QBluetoothServiceInfo) SocketProtocol() QBluetoothServiceInfo__Protocol {
if ptr.Pointer() != nil {
return QBluetoothServiceInfo__Protocol(C.QBluetoothServiceInfo_SocketProtocol(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothServiceInfo) UnregisterService() bool {
if ptr.Pointer() != nil {
return C.QBluetoothServiceInfo_UnregisterService(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothServiceInfo) DestroyQBluetoothServiceInfo() {
if ptr.Pointer() != nil {
C.QBluetoothServiceInfo_DestroyQBluetoothServiceInfo(C.QtObjectPtr(ptr.Pointer()))
}
}

31
bluetooth/qbluetoothserviceinfo.h Executable file
View file

@ -0,0 +1,31 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
int QBluetoothServiceInfo_ServiceName_Type();
int QBluetoothServiceInfo_ServiceDescription_Type();
int QBluetoothServiceInfo_ServiceProvider_Type();
char* QBluetoothServiceInfo_ServiceDescription(QtObjectPtr ptr);
char* QBluetoothServiceInfo_ServiceName(QtObjectPtr ptr);
char* QBluetoothServiceInfo_ServiceProvider(QtObjectPtr ptr);
void QBluetoothServiceInfo_SetServiceDescription(QtObjectPtr ptr, char* description);
void QBluetoothServiceInfo_SetServiceName(QtObjectPtr ptr, char* name);
void QBluetoothServiceInfo_SetServiceProvider(QtObjectPtr ptr, char* provider);
void QBluetoothServiceInfo_SetServiceUuid(QtObjectPtr ptr, QtObjectPtr uuid);
QtObjectPtr QBluetoothServiceInfo_NewQBluetoothServiceInfo();
QtObjectPtr QBluetoothServiceInfo_NewQBluetoothServiceInfo2(QtObjectPtr other);
int QBluetoothServiceInfo_IsComplete(QtObjectPtr ptr);
int QBluetoothServiceInfo_IsRegistered(QtObjectPtr ptr);
int QBluetoothServiceInfo_IsValid(QtObjectPtr ptr);
int QBluetoothServiceInfo_ProtocolServiceMultiplexer(QtObjectPtr ptr);
int QBluetoothServiceInfo_RegisterService(QtObjectPtr ptr, QtObjectPtr localAdapter);
int QBluetoothServiceInfo_ServerChannel(QtObjectPtr ptr);
void QBluetoothServiceInfo_SetDevice(QtObjectPtr ptr, QtObjectPtr device);
int QBluetoothServiceInfo_SocketProtocol(QtObjectPtr ptr);
int QBluetoothServiceInfo_UnregisterService(QtObjectPtr ptr);
void QBluetoothServiceInfo_DestroyQBluetoothServiceInfo(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

112
bluetooth/qbluetoothsocket.cpp Executable file
View file

@ -0,0 +1,112 @@
#include "qbluetoothsocket.h"
#include <QModelIndex>
#include <QBluetoothServiceInfo>
#include <QBluetoothAddress>
#include <QObject>
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QIODevice>
#include <QBluetoothUuid>
#include <QBluetoothSocket>
#include "_cgo_export.h"
class MyQBluetoothSocket: public QBluetoothSocket {
public:
void Signal_Connected(){callbackQBluetoothSocketConnected(this->objectName().toUtf8().data());};
void Signal_Disconnected(){callbackQBluetoothSocketDisconnected(this->objectName().toUtf8().data());};
void Signal_StateChanged(QBluetoothSocket::SocketState state){callbackQBluetoothSocketStateChanged(this->objectName().toUtf8().data(), state);};
};
void QBluetoothSocket_ConnectConnected(QtObjectPtr ptr){
QObject::connect(static_cast<QBluetoothSocket*>(ptr), static_cast<void (QBluetoothSocket::*)()>(&QBluetoothSocket::connected), static_cast<MyQBluetoothSocket*>(ptr), static_cast<void (MyQBluetoothSocket::*)()>(&MyQBluetoothSocket::Signal_Connected));;
}
void QBluetoothSocket_DisconnectConnected(QtObjectPtr ptr){
QObject::disconnect(static_cast<QBluetoothSocket*>(ptr), static_cast<void (QBluetoothSocket::*)()>(&QBluetoothSocket::connected), static_cast<MyQBluetoothSocket*>(ptr), static_cast<void (MyQBluetoothSocket::*)()>(&MyQBluetoothSocket::Signal_Connected));;
}
void QBluetoothSocket_ConnectDisconnected(QtObjectPtr ptr){
QObject::connect(static_cast<QBluetoothSocket*>(ptr), static_cast<void (QBluetoothSocket::*)()>(&QBluetoothSocket::disconnected), static_cast<MyQBluetoothSocket*>(ptr), static_cast<void (MyQBluetoothSocket::*)()>(&MyQBluetoothSocket::Signal_Disconnected));;
}
void QBluetoothSocket_DisconnectDisconnected(QtObjectPtr ptr){
QObject::disconnect(static_cast<QBluetoothSocket*>(ptr), static_cast<void (QBluetoothSocket::*)()>(&QBluetoothSocket::disconnected), static_cast<MyQBluetoothSocket*>(ptr), static_cast<void (MyQBluetoothSocket::*)()>(&MyQBluetoothSocket::Signal_Disconnected));;
}
void QBluetoothSocket_ConnectStateChanged(QtObjectPtr ptr){
QObject::connect(static_cast<QBluetoothSocket*>(ptr), static_cast<void (QBluetoothSocket::*)(QBluetoothSocket::SocketState)>(&QBluetoothSocket::stateChanged), static_cast<MyQBluetoothSocket*>(ptr), static_cast<void (MyQBluetoothSocket::*)(QBluetoothSocket::SocketState)>(&MyQBluetoothSocket::Signal_StateChanged));;
}
void QBluetoothSocket_DisconnectStateChanged(QtObjectPtr ptr){
QObject::disconnect(static_cast<QBluetoothSocket*>(ptr), static_cast<void (QBluetoothSocket::*)(QBluetoothSocket::SocketState)>(&QBluetoothSocket::stateChanged), static_cast<MyQBluetoothSocket*>(ptr), static_cast<void (MyQBluetoothSocket::*)(QBluetoothSocket::SocketState)>(&MyQBluetoothSocket::Signal_StateChanged));;
}
QtObjectPtr QBluetoothSocket_NewQBluetoothSocket(int socketType, QtObjectPtr parent){
return new QBluetoothSocket(static_cast<QBluetoothServiceInfo::Protocol>(socketType), static_cast<QObject*>(parent));
}
QtObjectPtr QBluetoothSocket_NewQBluetoothSocket2(QtObjectPtr parent){
return new QBluetoothSocket(static_cast<QObject*>(parent));
}
void QBluetoothSocket_Abort(QtObjectPtr ptr){
static_cast<QBluetoothSocket*>(ptr)->abort();
}
int QBluetoothSocket_CanReadLine(QtObjectPtr ptr){
return static_cast<QBluetoothSocket*>(ptr)->canReadLine();
}
void QBluetoothSocket_Close(QtObjectPtr ptr){
static_cast<QBluetoothSocket*>(ptr)->close();
}
void QBluetoothSocket_ConnectToService2(QtObjectPtr ptr, QtObjectPtr address, QtObjectPtr uuid, int openMode){
static_cast<QBluetoothSocket*>(ptr)->connectToService(*static_cast<QBluetoothAddress*>(address), *static_cast<QBluetoothUuid*>(uuid), static_cast<QIODevice::OpenModeFlag>(openMode));
}
void QBluetoothSocket_ConnectToService(QtObjectPtr ptr, QtObjectPtr service, int openMode){
static_cast<QBluetoothSocket*>(ptr)->connectToService(*static_cast<QBluetoothServiceInfo*>(service), static_cast<QIODevice::OpenModeFlag>(openMode));
}
void QBluetoothSocket_DisconnectFromService(QtObjectPtr ptr){
static_cast<QBluetoothSocket*>(ptr)->disconnectFromService();
}
int QBluetoothSocket_Error(QtObjectPtr ptr){
return static_cast<QBluetoothSocket*>(ptr)->error();
}
char* QBluetoothSocket_ErrorString(QtObjectPtr ptr){
return static_cast<QBluetoothSocket*>(ptr)->errorString().toUtf8().data();
}
int QBluetoothSocket_IsSequential(QtObjectPtr ptr){
return static_cast<QBluetoothSocket*>(ptr)->isSequential();
}
char* QBluetoothSocket_LocalName(QtObjectPtr ptr){
return static_cast<QBluetoothSocket*>(ptr)->localName().toUtf8().data();
}
char* QBluetoothSocket_PeerName(QtObjectPtr ptr){
return static_cast<QBluetoothSocket*>(ptr)->peerName().toUtf8().data();
}
int QBluetoothSocket_SetSocketDescriptor(QtObjectPtr ptr, int socketDescriptor, int socketType, int socketState, int openMode){
return static_cast<QBluetoothSocket*>(ptr)->setSocketDescriptor(socketDescriptor, static_cast<QBluetoothServiceInfo::Protocol>(socketType), static_cast<QBluetoothSocket::SocketState>(socketState), static_cast<QIODevice::OpenModeFlag>(openMode));
}
int QBluetoothSocket_SocketDescriptor(QtObjectPtr ptr){
return static_cast<QBluetoothSocket*>(ptr)->socketDescriptor();
}
int QBluetoothSocket_SocketType(QtObjectPtr ptr){
return static_cast<QBluetoothSocket*>(ptr)->socketType();
}
void QBluetoothSocket_DestroyQBluetoothSocket(QtObjectPtr ptr){
static_cast<QBluetoothSocket*>(ptr)->~QBluetoothSocket();
}

230
bluetooth/qbluetoothsocket.go Executable file
View file

@ -0,0 +1,230 @@
package bluetooth
//#include "qbluetoothsocket.h"
import "C"
import (
"github.com/therecipe/qt"
"github.com/therecipe/qt/core"
"github.com/therecipe/qt/network"
"unsafe"
)
type QBluetoothSocket struct {
core.QIODevice
}
type QBluetoothSocketITF interface {
core.QIODeviceITF
QBluetoothSocketPTR() *QBluetoothSocket
}
func PointerFromQBluetoothSocket(ptr QBluetoothSocketITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothSocketPTR().Pointer()
}
return nil
}
func QBluetoothSocketFromPointer(ptr unsafe.Pointer) *QBluetoothSocket {
var n = new(QBluetoothSocket)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QBluetoothSocket_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QBluetoothSocket) QBluetoothSocketPTR() *QBluetoothSocket {
return ptr
}
//QBluetoothSocket::SocketError
type QBluetoothSocket__SocketError int
var (
QBluetoothSocket__NoSocketError = QBluetoothSocket__SocketError(-2)
QBluetoothSocket__UnknownSocketError = QBluetoothSocket__SocketError(network.QAbstractSocket__UnknownSocketError)
QBluetoothSocket__HostNotFoundError = QBluetoothSocket__SocketError(network.QAbstractSocket__HostNotFoundError)
QBluetoothSocket__ServiceNotFoundError = QBluetoothSocket__SocketError(network.QAbstractSocket__SocketAddressNotAvailableError)
QBluetoothSocket__NetworkError = QBluetoothSocket__SocketError(network.QAbstractSocket__NetworkError)
QBluetoothSocket__UnsupportedProtocolError = QBluetoothSocket__SocketError(8)
QBluetoothSocket__OperationError = QBluetoothSocket__SocketError(network.QAbstractSocket__OperationError)
)
//QBluetoothSocket::SocketState
type QBluetoothSocket__SocketState int
var (
QBluetoothSocket__UnconnectedState = QBluetoothSocket__SocketState(network.QAbstractSocket__UnconnectedState)
QBluetoothSocket__ServiceLookupState = QBluetoothSocket__SocketState(network.QAbstractSocket__HostLookupState)
QBluetoothSocket__ConnectingState = QBluetoothSocket__SocketState(network.QAbstractSocket__ConnectingState)
QBluetoothSocket__ConnectedState = QBluetoothSocket__SocketState(network.QAbstractSocket__ConnectedState)
QBluetoothSocket__BoundState = QBluetoothSocket__SocketState(network.QAbstractSocket__BoundState)
QBluetoothSocket__ClosingState = QBluetoothSocket__SocketState(network.QAbstractSocket__ClosingState)
QBluetoothSocket__ListeningState = QBluetoothSocket__SocketState(network.QAbstractSocket__ListeningState)
)
func (ptr *QBluetoothSocket) ConnectConnected(f func()) {
if ptr.Pointer() != nil {
C.QBluetoothSocket_ConnectConnected(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "connected", f)
}
}
func (ptr *QBluetoothSocket) DisconnectConnected() {
if ptr.Pointer() != nil {
C.QBluetoothSocket_DisconnectConnected(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "connected")
}
}
//export callbackQBluetoothSocketConnected
func callbackQBluetoothSocketConnected(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "connected").(func())()
}
func (ptr *QBluetoothSocket) ConnectDisconnected(f func()) {
if ptr.Pointer() != nil {
C.QBluetoothSocket_ConnectDisconnected(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "disconnected", f)
}
}
func (ptr *QBluetoothSocket) DisconnectDisconnected() {
if ptr.Pointer() != nil {
C.QBluetoothSocket_DisconnectDisconnected(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "disconnected")
}
}
//export callbackQBluetoothSocketDisconnected
func callbackQBluetoothSocketDisconnected(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "disconnected").(func())()
}
func (ptr *QBluetoothSocket) ConnectStateChanged(f func(state QBluetoothSocket__SocketState)) {
if ptr.Pointer() != nil {
C.QBluetoothSocket_ConnectStateChanged(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "stateChanged", f)
}
}
func (ptr *QBluetoothSocket) DisconnectStateChanged() {
if ptr.Pointer() != nil {
C.QBluetoothSocket_DisconnectStateChanged(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "stateChanged")
}
}
//export callbackQBluetoothSocketStateChanged
func callbackQBluetoothSocketStateChanged(ptrName *C.char, state C.int) {
qt.GetSignal(C.GoString(ptrName), "stateChanged").(func(QBluetoothSocket__SocketState))(QBluetoothSocket__SocketState(state))
}
func NewQBluetoothSocket(socketType QBluetoothServiceInfo__Protocol, parent core.QObjectITF) *QBluetoothSocket {
return QBluetoothSocketFromPointer(unsafe.Pointer(C.QBluetoothSocket_NewQBluetoothSocket(C.int(socketType), C.QtObjectPtr(core.PointerFromQObject(parent)))))
}
func NewQBluetoothSocket2(parent core.QObjectITF) *QBluetoothSocket {
return QBluetoothSocketFromPointer(unsafe.Pointer(C.QBluetoothSocket_NewQBluetoothSocket2(C.QtObjectPtr(core.PointerFromQObject(parent)))))
}
func (ptr *QBluetoothSocket) Abort() {
if ptr.Pointer() != nil {
C.QBluetoothSocket_Abort(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QBluetoothSocket) CanReadLine() bool {
if ptr.Pointer() != nil {
return C.QBluetoothSocket_CanReadLine(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothSocket) Close() {
if ptr.Pointer() != nil {
C.QBluetoothSocket_Close(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QBluetoothSocket) ConnectToService2(address QBluetoothAddressITF, uuid QBluetoothUuidITF, openMode core.QIODevice__OpenModeFlag) {
if ptr.Pointer() != nil {
C.QBluetoothSocket_ConnectToService2(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothAddress(address)), C.QtObjectPtr(PointerFromQBluetoothUuid(uuid)), C.int(openMode))
}
}
func (ptr *QBluetoothSocket) ConnectToService(service QBluetoothServiceInfoITF, openMode core.QIODevice__OpenModeFlag) {
if ptr.Pointer() != nil {
C.QBluetoothSocket_ConnectToService(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothServiceInfo(service)), C.int(openMode))
}
}
func (ptr *QBluetoothSocket) DisconnectFromService() {
if ptr.Pointer() != nil {
C.QBluetoothSocket_DisconnectFromService(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QBluetoothSocket) Error() QBluetoothSocket__SocketError {
if ptr.Pointer() != nil {
return QBluetoothSocket__SocketError(C.QBluetoothSocket_Error(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothSocket) ErrorString() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothSocket_ErrorString(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothSocket) IsSequential() bool {
if ptr.Pointer() != nil {
return C.QBluetoothSocket_IsSequential(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothSocket) LocalName() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothSocket_LocalName(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothSocket) PeerName() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothSocket_PeerName(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothSocket) SetSocketDescriptor(socketDescriptor int, socketType QBluetoothServiceInfo__Protocol, socketState QBluetoothSocket__SocketState, openMode core.QIODevice__OpenModeFlag) bool {
if ptr.Pointer() != nil {
return C.QBluetoothSocket_SetSocketDescriptor(C.QtObjectPtr(ptr.Pointer()), C.int(socketDescriptor), C.int(socketType), C.int(socketState), C.int(openMode)) != 0
}
return false
}
func (ptr *QBluetoothSocket) SocketDescriptor() int {
if ptr.Pointer() != nil {
return int(C.QBluetoothSocket_SocketDescriptor(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothSocket) SocketType() QBluetoothServiceInfo__Protocol {
if ptr.Pointer() != nil {
return QBluetoothServiceInfo__Protocol(C.QBluetoothSocket_SocketType(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothSocket) DestroyQBluetoothSocket() {
if ptr.Pointer() != nil {
C.QBluetoothSocket_DestroyQBluetoothSocket(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

32
bluetooth/qbluetoothsocket.h Executable file
View file

@ -0,0 +1,32 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
void QBluetoothSocket_ConnectConnected(QtObjectPtr ptr);
void QBluetoothSocket_DisconnectConnected(QtObjectPtr ptr);
void QBluetoothSocket_ConnectDisconnected(QtObjectPtr ptr);
void QBluetoothSocket_DisconnectDisconnected(QtObjectPtr ptr);
void QBluetoothSocket_ConnectStateChanged(QtObjectPtr ptr);
void QBluetoothSocket_DisconnectStateChanged(QtObjectPtr ptr);
QtObjectPtr QBluetoothSocket_NewQBluetoothSocket(int socketType, QtObjectPtr parent);
QtObjectPtr QBluetoothSocket_NewQBluetoothSocket2(QtObjectPtr parent);
void QBluetoothSocket_Abort(QtObjectPtr ptr);
int QBluetoothSocket_CanReadLine(QtObjectPtr ptr);
void QBluetoothSocket_Close(QtObjectPtr ptr);
void QBluetoothSocket_ConnectToService2(QtObjectPtr ptr, QtObjectPtr address, QtObjectPtr uuid, int openMode);
void QBluetoothSocket_ConnectToService(QtObjectPtr ptr, QtObjectPtr service, int openMode);
void QBluetoothSocket_DisconnectFromService(QtObjectPtr ptr);
int QBluetoothSocket_Error(QtObjectPtr ptr);
char* QBluetoothSocket_ErrorString(QtObjectPtr ptr);
int QBluetoothSocket_IsSequential(QtObjectPtr ptr);
char* QBluetoothSocket_LocalName(QtObjectPtr ptr);
char* QBluetoothSocket_PeerName(QtObjectPtr ptr);
int QBluetoothSocket_SetSocketDescriptor(QtObjectPtr ptr, int socketDescriptor, int socketType, int socketState, int openMode);
int QBluetoothSocket_SocketDescriptor(QtObjectPtr ptr);
int QBluetoothSocket_SocketType(QtObjectPtr ptr);
void QBluetoothSocket_DestroyQBluetoothSocket(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

37
bluetooth/qbluetoothtransfermanager.cpp Executable file
View file

@ -0,0 +1,37 @@
#include "qbluetoothtransfermanager.h"
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QObject>
#include <QIODevice>
#include <QBluetoothTransferReply>
#include <QBluetoothTransferRequest>
#include <QString>
#include <QBluetoothTransferManager>
#include "_cgo_export.h"
class MyQBluetoothTransferManager: public QBluetoothTransferManager {
public:
void Signal_Finished(QBluetoothTransferReply * reply){callbackQBluetoothTransferManagerFinished(this->objectName().toUtf8().data(), reply);};
};
QtObjectPtr QBluetoothTransferManager_Put(QtObjectPtr ptr, QtObjectPtr request, QtObjectPtr data){
return static_cast<QBluetoothTransferManager*>(ptr)->put(*static_cast<QBluetoothTransferRequest*>(request), static_cast<QIODevice*>(data));
}
QtObjectPtr QBluetoothTransferManager_NewQBluetoothTransferManager(QtObjectPtr parent){
return new QBluetoothTransferManager(static_cast<QObject*>(parent));
}
void QBluetoothTransferManager_ConnectFinished(QtObjectPtr ptr){
QObject::connect(static_cast<QBluetoothTransferManager*>(ptr), static_cast<void (QBluetoothTransferManager::*)(QBluetoothTransferReply *)>(&QBluetoothTransferManager::finished), static_cast<MyQBluetoothTransferManager*>(ptr), static_cast<void (MyQBluetoothTransferManager::*)(QBluetoothTransferReply *)>(&MyQBluetoothTransferManager::Signal_Finished));;
}
void QBluetoothTransferManager_DisconnectFinished(QtObjectPtr ptr){
QObject::disconnect(static_cast<QBluetoothTransferManager*>(ptr), static_cast<void (QBluetoothTransferManager::*)(QBluetoothTransferReply *)>(&QBluetoothTransferManager::finished), static_cast<MyQBluetoothTransferManager*>(ptr), static_cast<void (MyQBluetoothTransferManager::*)(QBluetoothTransferReply *)>(&MyQBluetoothTransferManager::Signal_Finished));;
}
void QBluetoothTransferManager_DestroyQBluetoothTransferManager(QtObjectPtr ptr){
static_cast<QBluetoothTransferManager*>(ptr)->~QBluetoothTransferManager();
}

75
bluetooth/qbluetoothtransfermanager.go Executable file
View file

@ -0,0 +1,75 @@
package bluetooth
//#include "qbluetoothtransfermanager.h"
import "C"
import (
"github.com/therecipe/qt"
"github.com/therecipe/qt/core"
"unsafe"
)
type QBluetoothTransferManager struct {
core.QObject
}
type QBluetoothTransferManagerITF interface {
core.QObjectITF
QBluetoothTransferManagerPTR() *QBluetoothTransferManager
}
func PointerFromQBluetoothTransferManager(ptr QBluetoothTransferManagerITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothTransferManagerPTR().Pointer()
}
return nil
}
func QBluetoothTransferManagerFromPointer(ptr unsafe.Pointer) *QBluetoothTransferManager {
var n = new(QBluetoothTransferManager)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QBluetoothTransferManager_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QBluetoothTransferManager) QBluetoothTransferManagerPTR() *QBluetoothTransferManager {
return ptr
}
func (ptr *QBluetoothTransferManager) Put(request QBluetoothTransferRequestITF, data core.QIODeviceITF) *QBluetoothTransferReply {
if ptr.Pointer() != nil {
return QBluetoothTransferReplyFromPointer(unsafe.Pointer(C.QBluetoothTransferManager_Put(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothTransferRequest(request)), C.QtObjectPtr(core.PointerFromQIODevice(data)))))
}
return nil
}
func NewQBluetoothTransferManager(parent core.QObjectITF) *QBluetoothTransferManager {
return QBluetoothTransferManagerFromPointer(unsafe.Pointer(C.QBluetoothTransferManager_NewQBluetoothTransferManager(C.QtObjectPtr(core.PointerFromQObject(parent)))))
}
func (ptr *QBluetoothTransferManager) ConnectFinished(f func(reply QBluetoothTransferReplyITF)) {
if ptr.Pointer() != nil {
C.QBluetoothTransferManager_ConnectFinished(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "finished", f)
}
}
func (ptr *QBluetoothTransferManager) DisconnectFinished() {
if ptr.Pointer() != nil {
C.QBluetoothTransferManager_DisconnectFinished(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "finished")
}
}
//export callbackQBluetoothTransferManagerFinished
func callbackQBluetoothTransferManagerFinished(ptrName *C.char, reply unsafe.Pointer) {
qt.GetSignal(C.GoString(ptrName), "finished").(func(*QBluetoothTransferReply))(QBluetoothTransferReplyFromPointer(reply))
}
func (ptr *QBluetoothTransferManager) DestroyQBluetoothTransferManager() {
if ptr.Pointer() != nil {
C.QBluetoothTransferManager_DestroyQBluetoothTransferManager(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

14
bluetooth/qbluetoothtransfermanager.h Executable file
View file

@ -0,0 +1,14 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QBluetoothTransferManager_Put(QtObjectPtr ptr, QtObjectPtr request, QtObjectPtr data);
QtObjectPtr QBluetoothTransferManager_NewQBluetoothTransferManager(QtObjectPtr parent);
void QBluetoothTransferManager_ConnectFinished(QtObjectPtr ptr);
void QBluetoothTransferManager_DisconnectFinished(QtObjectPtr ptr);
void QBluetoothTransferManager_DestroyQBluetoothTransferManager(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

51
bluetooth/qbluetoothtransferreply.cpp Executable file
View file

@ -0,0 +1,51 @@
#include "qbluetoothtransferreply.h"
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QMetaObject>
#include <QObject>
#include <QBluetoothTransferReply>
#include "_cgo_export.h"
class MyQBluetoothTransferReply: public QBluetoothTransferReply {
public:
void Signal_Finished(QBluetoothTransferReply * reply){callbackQBluetoothTransferReplyFinished(this->objectName().toUtf8().data(), reply);};
};
void QBluetoothTransferReply_Abort(QtObjectPtr ptr){
QMetaObject::invokeMethod(static_cast<QBluetoothTransferReply*>(ptr), "abort");
}
int QBluetoothTransferReply_Error(QtObjectPtr ptr){
return static_cast<QBluetoothTransferReply*>(ptr)->error();
}
char* QBluetoothTransferReply_ErrorString(QtObjectPtr ptr){
return static_cast<QBluetoothTransferReply*>(ptr)->errorString().toUtf8().data();
}
void QBluetoothTransferReply_ConnectFinished(QtObjectPtr ptr){
QObject::connect(static_cast<QBluetoothTransferReply*>(ptr), static_cast<void (QBluetoothTransferReply::*)(QBluetoothTransferReply *)>(&QBluetoothTransferReply::finished), static_cast<MyQBluetoothTransferReply*>(ptr), static_cast<void (MyQBluetoothTransferReply::*)(QBluetoothTransferReply *)>(&MyQBluetoothTransferReply::Signal_Finished));;
}
void QBluetoothTransferReply_DisconnectFinished(QtObjectPtr ptr){
QObject::disconnect(static_cast<QBluetoothTransferReply*>(ptr), static_cast<void (QBluetoothTransferReply::*)(QBluetoothTransferReply *)>(&QBluetoothTransferReply::finished), static_cast<MyQBluetoothTransferReply*>(ptr), static_cast<void (MyQBluetoothTransferReply::*)(QBluetoothTransferReply *)>(&MyQBluetoothTransferReply::Signal_Finished));;
}
int QBluetoothTransferReply_IsFinished(QtObjectPtr ptr){
return static_cast<QBluetoothTransferReply*>(ptr)->isFinished();
}
int QBluetoothTransferReply_IsRunning(QtObjectPtr ptr){
return static_cast<QBluetoothTransferReply*>(ptr)->isRunning();
}
QtObjectPtr QBluetoothTransferReply_Manager(QtObjectPtr ptr){
return static_cast<QBluetoothTransferReply*>(ptr)->manager();
}
void QBluetoothTransferReply_DestroyQBluetoothTransferReply(QtObjectPtr ptr){
static_cast<QBluetoothTransferReply*>(ptr)->~QBluetoothTransferReply();
}

119
bluetooth/qbluetoothtransferreply.go Executable file
View file

@ -0,0 +1,119 @@
package bluetooth
//#include "qbluetoothtransferreply.h"
import "C"
import (
"github.com/therecipe/qt"
"github.com/therecipe/qt/core"
"unsafe"
)
type QBluetoothTransferReply struct {
core.QObject
}
type QBluetoothTransferReplyITF interface {
core.QObjectITF
QBluetoothTransferReplyPTR() *QBluetoothTransferReply
}
func PointerFromQBluetoothTransferReply(ptr QBluetoothTransferReplyITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothTransferReplyPTR().Pointer()
}
return nil
}
func QBluetoothTransferReplyFromPointer(ptr unsafe.Pointer) *QBluetoothTransferReply {
var n = new(QBluetoothTransferReply)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QBluetoothTransferReply_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QBluetoothTransferReply) QBluetoothTransferReplyPTR() *QBluetoothTransferReply {
return ptr
}
//QBluetoothTransferReply::TransferError
type QBluetoothTransferReply__TransferError int
var (
QBluetoothTransferReply__NoError = QBluetoothTransferReply__TransferError(0)
QBluetoothTransferReply__UnknownError = QBluetoothTransferReply__TransferError(1)
QBluetoothTransferReply__FileNotFoundError = QBluetoothTransferReply__TransferError(2)
QBluetoothTransferReply__HostNotFoundError = QBluetoothTransferReply__TransferError(3)
QBluetoothTransferReply__UserCanceledTransferError = QBluetoothTransferReply__TransferError(4)
QBluetoothTransferReply__IODeviceNotReadableError = QBluetoothTransferReply__TransferError(5)
QBluetoothTransferReply__ResourceBusyError = QBluetoothTransferReply__TransferError(6)
QBluetoothTransferReply__SessionError = QBluetoothTransferReply__TransferError(7)
)
func (ptr *QBluetoothTransferReply) Abort() {
if ptr.Pointer() != nil {
C.QBluetoothTransferReply_Abort(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QBluetoothTransferReply) Error() QBluetoothTransferReply__TransferError {
if ptr.Pointer() != nil {
return QBluetoothTransferReply__TransferError(C.QBluetoothTransferReply_Error(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QBluetoothTransferReply) ErrorString() string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothTransferReply_ErrorString(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QBluetoothTransferReply) ConnectFinished(f func(reply QBluetoothTransferReplyITF)) {
if ptr.Pointer() != nil {
C.QBluetoothTransferReply_ConnectFinished(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "finished", f)
}
}
func (ptr *QBluetoothTransferReply) DisconnectFinished() {
if ptr.Pointer() != nil {
C.QBluetoothTransferReply_DisconnectFinished(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "finished")
}
}
//export callbackQBluetoothTransferReplyFinished
func callbackQBluetoothTransferReplyFinished(ptrName *C.char, reply unsafe.Pointer) {
qt.GetSignal(C.GoString(ptrName), "finished").(func(*QBluetoothTransferReply))(QBluetoothTransferReplyFromPointer(reply))
}
func (ptr *QBluetoothTransferReply) IsFinished() bool {
if ptr.Pointer() != nil {
return C.QBluetoothTransferReply_IsFinished(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothTransferReply) IsRunning() bool {
if ptr.Pointer() != nil {
return C.QBluetoothTransferReply_IsRunning(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QBluetoothTransferReply) Manager() *QBluetoothTransferManager {
if ptr.Pointer() != nil {
return QBluetoothTransferManagerFromPointer(unsafe.Pointer(C.QBluetoothTransferReply_Manager(C.QtObjectPtr(ptr.Pointer()))))
}
return nil
}
func (ptr *QBluetoothTransferReply) DestroyQBluetoothTransferReply() {
if ptr.Pointer() != nil {
C.QBluetoothTransferReply_DestroyQBluetoothTransferReply(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

18
bluetooth/qbluetoothtransferreply.h Executable file
View file

@ -0,0 +1,18 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
void QBluetoothTransferReply_Abort(QtObjectPtr ptr);
int QBluetoothTransferReply_Error(QtObjectPtr ptr);
char* QBluetoothTransferReply_ErrorString(QtObjectPtr ptr);
void QBluetoothTransferReply_ConnectFinished(QtObjectPtr ptr);
void QBluetoothTransferReply_DisconnectFinished(QtObjectPtr ptr);
int QBluetoothTransferReply_IsFinished(QtObjectPtr ptr);
int QBluetoothTransferReply_IsRunning(QtObjectPtr ptr);
QtObjectPtr QBluetoothTransferReply_Manager(QtObjectPtr ptr);
void QBluetoothTransferReply_DestroyQBluetoothTransferReply(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

33
bluetooth/qbluetoothtransferrequest.cpp Executable file
View file

@ -0,0 +1,33 @@
#include "qbluetoothtransferrequest.h"
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QBluetoothAddress>
#include <QBluetoothTransferRequest>
#include "_cgo_export.h"
class MyQBluetoothTransferRequest: public QBluetoothTransferRequest {
public:
};
QtObjectPtr QBluetoothTransferRequest_NewQBluetoothTransferRequest(QtObjectPtr address){
return new QBluetoothTransferRequest(*static_cast<QBluetoothAddress*>(address));
}
QtObjectPtr QBluetoothTransferRequest_NewQBluetoothTransferRequest2(QtObjectPtr other){
return new QBluetoothTransferRequest(*static_cast<QBluetoothTransferRequest*>(other));
}
char* QBluetoothTransferRequest_Attribute(QtObjectPtr ptr, int code, char* defaultValue){
return static_cast<QBluetoothTransferRequest*>(ptr)->attribute(static_cast<QBluetoothTransferRequest::Attribute>(code), QVariant(defaultValue)).toString().toUtf8().data();
}
void QBluetoothTransferRequest_SetAttribute(QtObjectPtr ptr, int code, char* value){
static_cast<QBluetoothTransferRequest*>(ptr)->setAttribute(static_cast<QBluetoothTransferRequest::Attribute>(code), QVariant(value));
}
void QBluetoothTransferRequest_DestroyQBluetoothTransferRequest(QtObjectPtr ptr){
static_cast<QBluetoothTransferRequest*>(ptr)->~QBluetoothTransferRequest();
}

78
bluetooth/qbluetoothtransferrequest.go Executable file
View file

@ -0,0 +1,78 @@
package bluetooth
//#include "qbluetoothtransferrequest.h"
import "C"
import (
"unsafe"
)
type QBluetoothTransferRequest struct {
ptr unsafe.Pointer
}
type QBluetoothTransferRequestITF interface {
QBluetoothTransferRequestPTR() *QBluetoothTransferRequest
}
func (p *QBluetoothTransferRequest) Pointer() unsafe.Pointer {
return p.ptr
}
func (p *QBluetoothTransferRequest) SetPointer(ptr unsafe.Pointer) {
p.ptr = ptr
}
func PointerFromQBluetoothTransferRequest(ptr QBluetoothTransferRequestITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothTransferRequestPTR().Pointer()
}
return nil
}
func QBluetoothTransferRequestFromPointer(ptr unsafe.Pointer) *QBluetoothTransferRequest {
var n = new(QBluetoothTransferRequest)
n.SetPointer(ptr)
return n
}
func (ptr *QBluetoothTransferRequest) QBluetoothTransferRequestPTR() *QBluetoothTransferRequest {
return ptr
}
//QBluetoothTransferRequest::Attribute
type QBluetoothTransferRequest__Attribute int
var (
QBluetoothTransferRequest__DescriptionAttribute = QBluetoothTransferRequest__Attribute(0)
QBluetoothTransferRequest__TimeAttribute = QBluetoothTransferRequest__Attribute(1)
QBluetoothTransferRequest__TypeAttribute = QBluetoothTransferRequest__Attribute(2)
QBluetoothTransferRequest__LengthAttribute = QBluetoothTransferRequest__Attribute(3)
QBluetoothTransferRequest__NameAttribute = QBluetoothTransferRequest__Attribute(4)
)
func NewQBluetoothTransferRequest(address QBluetoothAddressITF) *QBluetoothTransferRequest {
return QBluetoothTransferRequestFromPointer(unsafe.Pointer(C.QBluetoothTransferRequest_NewQBluetoothTransferRequest(C.QtObjectPtr(PointerFromQBluetoothAddress(address)))))
}
func NewQBluetoothTransferRequest2(other QBluetoothTransferRequestITF) *QBluetoothTransferRequest {
return QBluetoothTransferRequestFromPointer(unsafe.Pointer(C.QBluetoothTransferRequest_NewQBluetoothTransferRequest2(C.QtObjectPtr(PointerFromQBluetoothTransferRequest(other)))))
}
func (ptr *QBluetoothTransferRequest) Attribute(code QBluetoothTransferRequest__Attribute, defaultValue string) string {
if ptr.Pointer() != nil {
return C.GoString(C.QBluetoothTransferRequest_Attribute(C.QtObjectPtr(ptr.Pointer()), C.int(code), C.CString(defaultValue)))
}
return ""
}
func (ptr *QBluetoothTransferRequest) SetAttribute(code QBluetoothTransferRequest__Attribute, value string) {
if ptr.Pointer() != nil {
C.QBluetoothTransferRequest_SetAttribute(C.QtObjectPtr(ptr.Pointer()), C.int(code), C.CString(value))
}
}
func (ptr *QBluetoothTransferRequest) DestroyQBluetoothTransferRequest() {
if ptr.Pointer() != nil {
C.QBluetoothTransferRequest_DestroyQBluetoothTransferRequest(C.QtObjectPtr(ptr.Pointer()))
}
}

14
bluetooth/qbluetoothtransferrequest.h Executable file
View file

@ -0,0 +1,14 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QBluetoothTransferRequest_NewQBluetoothTransferRequest(QtObjectPtr address);
QtObjectPtr QBluetoothTransferRequest_NewQBluetoothTransferRequest2(QtObjectPtr other);
char* QBluetoothTransferRequest_Attribute(QtObjectPtr ptr, int code, char* defaultValue);
void QBluetoothTransferRequest_SetAttribute(QtObjectPtr ptr, int code, char* value);
void QBluetoothTransferRequest_DestroyQBluetoothTransferRequest(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

69
bluetooth/qbluetoothuuid.cpp Executable file
View file

@ -0,0 +1,69 @@
#include "qbluetoothuuid.h"
#include <QModelIndex>
#include <QUuid>
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QBluetoothUuid>
#include "_cgo_export.h"
class MyQBluetoothUuid: public QBluetoothUuid {
public:
};
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid(){
return new QBluetoothUuid();
}
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid4(int uuid){
return new QBluetoothUuid(static_cast<QBluetoothUuid::CharacteristicType>(uuid));
}
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid5(int uuid){
return new QBluetoothUuid(static_cast<QBluetoothUuid::DescriptorType>(uuid));
}
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid2(int uuid){
return new QBluetoothUuid(static_cast<QBluetoothUuid::ProtocolUuid>(uuid));
}
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid3(int uuid){
return new QBluetoothUuid(static_cast<QBluetoothUuid::ServiceClassUuid>(uuid));
}
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid10(QtObjectPtr uuid){
return new QBluetoothUuid(*static_cast<QBluetoothUuid*>(uuid));
}
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid9(char* uuid){
return new QBluetoothUuid(QString(uuid));
}
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid11(QtObjectPtr uuid){
return new QBluetoothUuid(*static_cast<QUuid*>(uuid));
}
char* QBluetoothUuid_QBluetoothUuid_CharacteristicToString(int uuid){
return QBluetoothUuid::characteristicToString(static_cast<QBluetoothUuid::CharacteristicType>(uuid)).toUtf8().data();
}
char* QBluetoothUuid_QBluetoothUuid_DescriptorToString(int uuid){
return QBluetoothUuid::descriptorToString(static_cast<QBluetoothUuid::DescriptorType>(uuid)).toUtf8().data();
}
int QBluetoothUuid_MinimumSize(QtObjectPtr ptr){
return static_cast<QBluetoothUuid*>(ptr)->minimumSize();
}
char* QBluetoothUuid_QBluetoothUuid_ProtocolToString(int uuid){
return QBluetoothUuid::protocolToString(static_cast<QBluetoothUuid::ProtocolUuid>(uuid)).toUtf8().data();
}
char* QBluetoothUuid_QBluetoothUuid_ServiceClassToString(int uuid){
return QBluetoothUuid::serviceClassToString(static_cast<QBluetoothUuid::ServiceClassUuid>(uuid)).toUtf8().data();
}
void QBluetoothUuid_DestroyQBluetoothUuid(QtObjectPtr ptr){
static_cast<QBluetoothUuid*>(ptr)->~QBluetoothUuid();
}

385
bluetooth/qbluetoothuuid.go Executable file
View file

@ -0,0 +1,385 @@
package bluetooth
//#include "qbluetoothuuid.h"
import "C"
import (
"github.com/therecipe/qt/core"
"unsafe"
)
type QBluetoothUuid struct {
core.QUuid
}
type QBluetoothUuidITF interface {
core.QUuidITF
QBluetoothUuidPTR() *QBluetoothUuid
}
func PointerFromQBluetoothUuid(ptr QBluetoothUuidITF) unsafe.Pointer {
if ptr != nil {
return ptr.QBluetoothUuidPTR().Pointer()
}
return nil
}
func QBluetoothUuidFromPointer(ptr unsafe.Pointer) *QBluetoothUuid {
var n = new(QBluetoothUuid)
n.SetPointer(ptr)
return n
}
func (ptr *QBluetoothUuid) QBluetoothUuidPTR() *QBluetoothUuid {
return ptr
}
//QBluetoothUuid::CharacteristicType
type QBluetoothUuid__CharacteristicType int
var (
QBluetoothUuid__DeviceName = QBluetoothUuid__CharacteristicType(0x2a00)
QBluetoothUuid__Appearance = QBluetoothUuid__CharacteristicType(0x2a01)
QBluetoothUuid__PeripheralPrivacyFlag = QBluetoothUuid__CharacteristicType(0x2a02)
QBluetoothUuid__ReconnectionAddress = QBluetoothUuid__CharacteristicType(0x2a03)
QBluetoothUuid__PeripheralPreferredConnectionParameters = QBluetoothUuid__CharacteristicType(0x2a04)
QBluetoothUuid__ServiceChanged = QBluetoothUuid__CharacteristicType(0x2a05)
QBluetoothUuid__AlertLevel = QBluetoothUuid__CharacteristicType(0x2a06)
QBluetoothUuid__TxPowerLevel = QBluetoothUuid__CharacteristicType(0x2a07)
QBluetoothUuid__DateTime = QBluetoothUuid__CharacteristicType(0x2a08)
QBluetoothUuid__DayOfWeek = QBluetoothUuid__CharacteristicType(0x2a09)
QBluetoothUuid__DayDateTime = QBluetoothUuid__CharacteristicType(0x2a0a)
QBluetoothUuid__ExactTime256 = QBluetoothUuid__CharacteristicType(0x2a0c)
QBluetoothUuid__DSTOffset = QBluetoothUuid__CharacteristicType(0x2a0d)
QBluetoothUuid__TimeZone = QBluetoothUuid__CharacteristicType(0x2a0e)
QBluetoothUuid__LocalTimeInformation = QBluetoothUuid__CharacteristicType(0x2a0f)
QBluetoothUuid__TimeWithDST = QBluetoothUuid__CharacteristicType(0x2a11)
QBluetoothUuid__TimeAccuracy = QBluetoothUuid__CharacteristicType(0x2a12)
QBluetoothUuid__TimeSource = QBluetoothUuid__CharacteristicType(0x2a13)
QBluetoothUuid__ReferenceTimeInformation = QBluetoothUuid__CharacteristicType(0x2a14)
QBluetoothUuid__TimeUpdateControlPoint = QBluetoothUuid__CharacteristicType(0x2a16)
QBluetoothUuid__TimeUpdateState = QBluetoothUuid__CharacteristicType(0x2a17)
QBluetoothUuid__GlucoseMeasurement = QBluetoothUuid__CharacteristicType(0x2a18)
QBluetoothUuid__BatteryLevel = QBluetoothUuid__CharacteristicType(0x2a19)
QBluetoothUuid__TemperatureMeasurement = QBluetoothUuid__CharacteristicType(0x2a1c)
QBluetoothUuid__TemperatureType = QBluetoothUuid__CharacteristicType(0x2a1d)
QBluetoothUuid__IntermediateTemperature = QBluetoothUuid__CharacteristicType(0x2a1e)
QBluetoothUuid__MeasurementInterval = QBluetoothUuid__CharacteristicType(0x2a21)
QBluetoothUuid__BootKeyboardInputReport = QBluetoothUuid__CharacteristicType(0x2a22)
QBluetoothUuid__SystemID = QBluetoothUuid__CharacteristicType(0x2a23)
QBluetoothUuid__ModelNumberString = QBluetoothUuid__CharacteristicType(0x2a24)
QBluetoothUuid__SerialNumberString = QBluetoothUuid__CharacteristicType(0x2a25)
QBluetoothUuid__FirmwareRevisionString = QBluetoothUuid__CharacteristicType(0x2a26)
QBluetoothUuid__HardwareRevisionString = QBluetoothUuid__CharacteristicType(0x2a27)
QBluetoothUuid__SoftwareRevisionString = QBluetoothUuid__CharacteristicType(0x2a28)
QBluetoothUuid__ManufacturerNameString = QBluetoothUuid__CharacteristicType(0x2a29)
QBluetoothUuid__IEEE1107320601RegulatoryCertificationDataList = QBluetoothUuid__CharacteristicType(0x2a2a)
QBluetoothUuid__CurrentTime = QBluetoothUuid__CharacteristicType(0x2a2b)
QBluetoothUuid__MagneticDeclination = QBluetoothUuid__CharacteristicType(0x2a2c)
QBluetoothUuid__ScanRefresh = QBluetoothUuid__CharacteristicType(0x2a31)
QBluetoothUuid__BootKeyboardOutputReport = QBluetoothUuid__CharacteristicType(0x2a32)
QBluetoothUuid__BootMouseInputReport = QBluetoothUuid__CharacteristicType(0x2a33)
QBluetoothUuid__GlucoseMeasurementContext = QBluetoothUuid__CharacteristicType(0x2a34)
QBluetoothUuid__BloodPressureMeasurement = QBluetoothUuid__CharacteristicType(0x2a35)
QBluetoothUuid__IntermediateCuffPressure = QBluetoothUuid__CharacteristicType(0x2a36)
QBluetoothUuid__HeartRateMeasurement = QBluetoothUuid__CharacteristicType(0x2a37)
QBluetoothUuid__BodySensorLocation = QBluetoothUuid__CharacteristicType(0x2a38)
QBluetoothUuid__HeartRateControlPoint = QBluetoothUuid__CharacteristicType(0x2a39)
QBluetoothUuid__AlertStatus = QBluetoothUuid__CharacteristicType(0x2a3f)
QBluetoothUuid__RingerControlPoint = QBluetoothUuid__CharacteristicType(0x2a40)
QBluetoothUuid__RingerSetting = QBluetoothUuid__CharacteristicType(0x2a41)
QBluetoothUuid__AlertCategoryIDBitMask = QBluetoothUuid__CharacteristicType(0x2a42)
QBluetoothUuid__AlertCategoryID = QBluetoothUuid__CharacteristicType(0x2a43)
QBluetoothUuid__AlertNotificationControlPoint = QBluetoothUuid__CharacteristicType(0x2a44)
QBluetoothUuid__UnreadAlertStatus = QBluetoothUuid__CharacteristicType(0x2a45)
QBluetoothUuid__NewAlert = QBluetoothUuid__CharacteristicType(0x2a46)
QBluetoothUuid__SupportedNewAlertCategory = QBluetoothUuid__CharacteristicType(0x2a47)
QBluetoothUuid__SupportedUnreadAlertCategory = QBluetoothUuid__CharacteristicType(0x2a48)
QBluetoothUuid__BloodPressureFeature = QBluetoothUuid__CharacteristicType(0x2a49)
QBluetoothUuid__HIDInformation = QBluetoothUuid__CharacteristicType(0x2a4a)
QBluetoothUuid__ReportMap = QBluetoothUuid__CharacteristicType(0x2a4b)
QBluetoothUuid__HIDControlPoint = QBluetoothUuid__CharacteristicType(0x2a4c)
QBluetoothUuid__Report = QBluetoothUuid__CharacteristicType(0x2a4d)
QBluetoothUuid__ProtocolMode = QBluetoothUuid__CharacteristicType(0x2a4e)
QBluetoothUuid__ScanIntervalWindow = QBluetoothUuid__CharacteristicType(0x2a4f)
QBluetoothUuid__PnPID = QBluetoothUuid__CharacteristicType(0x2a50)
QBluetoothUuid__GlucoseFeature = QBluetoothUuid__CharacteristicType(0x2a51)
QBluetoothUuid__RecordAccessControlPoint = QBluetoothUuid__CharacteristicType(0x2a52)
QBluetoothUuid__RSCMeasurement = QBluetoothUuid__CharacteristicType(0x2a53)
QBluetoothUuid__RSCFeature = QBluetoothUuid__CharacteristicType(0x2a54)
QBluetoothUuid__SCControlPoint = QBluetoothUuid__CharacteristicType(0x2a55)
QBluetoothUuid__CSCMeasurement = QBluetoothUuid__CharacteristicType(0x2a5b)
QBluetoothUuid__CSCFeature = QBluetoothUuid__CharacteristicType(0x2a5c)
QBluetoothUuid__SensorLocation = QBluetoothUuid__CharacteristicType(0x2a5d)
QBluetoothUuid__CyclingPowerMeasurement = QBluetoothUuid__CharacteristicType(0x2a63)
QBluetoothUuid__CyclingPowerVector = QBluetoothUuid__CharacteristicType(0x2a64)
QBluetoothUuid__CyclingPowerFeature = QBluetoothUuid__CharacteristicType(0x2a65)
QBluetoothUuid__CyclingPowerControlPoint = QBluetoothUuid__CharacteristicType(0x2a66)
QBluetoothUuid__LocationAndSpeed = QBluetoothUuid__CharacteristicType(0x2a67)
QBluetoothUuid__Navigation = QBluetoothUuid__CharacteristicType(0x2a68)
QBluetoothUuid__PositionQuality = QBluetoothUuid__CharacteristicType(0x2a69)
QBluetoothUuid__LNFeature = QBluetoothUuid__CharacteristicType(0x2a6a)
QBluetoothUuid__LNControlPoint = QBluetoothUuid__CharacteristicType(0x2a6b)
QBluetoothUuid__Elevation = QBluetoothUuid__CharacteristicType(0x2a6c)
QBluetoothUuid__Pressure = QBluetoothUuid__CharacteristicType(0x2a6d)
QBluetoothUuid__Temperature = QBluetoothUuid__CharacteristicType(0x2a6e)
QBluetoothUuid__Humidity = QBluetoothUuid__CharacteristicType(0x2a6f)
QBluetoothUuid__TrueWindSpeed = QBluetoothUuid__CharacteristicType(0x2a70)
QBluetoothUuid__TrueWindDirection = QBluetoothUuid__CharacteristicType(0x2a71)
QBluetoothUuid__ApparentWindSpeed = QBluetoothUuid__CharacteristicType(0x2a72)
QBluetoothUuid__ApparentWindDirection = QBluetoothUuid__CharacteristicType(0x2a73)
QBluetoothUuid__GustFactor = QBluetoothUuid__CharacteristicType(0x2a74)
QBluetoothUuid__PollenConcentration = QBluetoothUuid__CharacteristicType(0x2a75)
QBluetoothUuid__UVIndex = QBluetoothUuid__CharacteristicType(0x2a76)
QBluetoothUuid__Irradiance = QBluetoothUuid__CharacteristicType(0x2a77)
QBluetoothUuid__Rainfall = QBluetoothUuid__CharacteristicType(0x2a78)
QBluetoothUuid__WindChill = QBluetoothUuid__CharacteristicType(0x2a79)
QBluetoothUuid__HeatIndex = QBluetoothUuid__CharacteristicType(0x2a7a)
QBluetoothUuid__DewPoint = QBluetoothUuid__CharacteristicType(0x2a7b)
QBluetoothUuid__DescriptorValueChanged = QBluetoothUuid__CharacteristicType(0x2a7d)
QBluetoothUuid__AerobicHeartRateLowerLimit = QBluetoothUuid__CharacteristicType(0x2a7e)
QBluetoothUuid__AerobicThreshold = QBluetoothUuid__CharacteristicType(0x2a7f)
QBluetoothUuid__Age = QBluetoothUuid__CharacteristicType(0x2a80)
QBluetoothUuid__AnaerobicHeartRateLowerLimit = QBluetoothUuid__CharacteristicType(0x2a81)
QBluetoothUuid__AnaerobicHeartRateUpperLimit = QBluetoothUuid__CharacteristicType(0x2a82)
QBluetoothUuid__AnaerobicThreshold = QBluetoothUuid__CharacteristicType(0x2a83)
QBluetoothUuid__AerobicHeartRateUpperLimit = QBluetoothUuid__CharacteristicType(0x2a84)
QBluetoothUuid__DateOfBirth = QBluetoothUuid__CharacteristicType(0x2a85)
QBluetoothUuid__DateOfThresholdAssessment = QBluetoothUuid__CharacteristicType(0x2a86)
QBluetoothUuid__EmailAddress = QBluetoothUuid__CharacteristicType(0x2a87)
QBluetoothUuid__FatBurnHeartRateLowerLimit = QBluetoothUuid__CharacteristicType(0x2a88)
QBluetoothUuid__FatBurnHeartRateUpperLimit = QBluetoothUuid__CharacteristicType(0x2a89)
QBluetoothUuid__FirstName = QBluetoothUuid__CharacteristicType(0x2a8a)
QBluetoothUuid__FiveZoneHeartRateLimits = QBluetoothUuid__CharacteristicType(0x2a8b)
QBluetoothUuid__Gender = QBluetoothUuid__CharacteristicType(0x2a8c)
QBluetoothUuid__HeartRateMax = QBluetoothUuid__CharacteristicType(0x2a8d)
QBluetoothUuid__Height = QBluetoothUuid__CharacteristicType(0x2a8e)
QBluetoothUuid__HipCircumference = QBluetoothUuid__CharacteristicType(0x2a8f)
QBluetoothUuid__LastName = QBluetoothUuid__CharacteristicType(0x2a90)
QBluetoothUuid__MaximumRecommendedHeartRate = QBluetoothUuid__CharacteristicType(0x2a91)
QBluetoothUuid__RestingHeartRate = QBluetoothUuid__CharacteristicType(0x2a92)
QBluetoothUuid__SportTypeForAerobicAnaerobicThresholds = QBluetoothUuid__CharacteristicType(0x2a93)
QBluetoothUuid__ThreeZoneHeartRateLimits = QBluetoothUuid__CharacteristicType(0x2a94)
QBluetoothUuid__TwoZoneHeartRateLimits = QBluetoothUuid__CharacteristicType(0x2a95)
QBluetoothUuid__VO2Max = QBluetoothUuid__CharacteristicType(0x2a96)
QBluetoothUuid__WaistCircumference = QBluetoothUuid__CharacteristicType(0x2a97)
QBluetoothUuid__Weight = QBluetoothUuid__CharacteristicType(0x2a98)
QBluetoothUuid__DatabaseChangeIncrement = QBluetoothUuid__CharacteristicType(0x2a99)
QBluetoothUuid__UserIndex = QBluetoothUuid__CharacteristicType(0x2a9a)
QBluetoothUuid__BodyCompositionFeature = QBluetoothUuid__CharacteristicType(0x2a9b)
QBluetoothUuid__BodyCompositionMeasurement = QBluetoothUuid__CharacteristicType(0x2a9c)
QBluetoothUuid__WeightMeasurement = QBluetoothUuid__CharacteristicType(0x2a9d)
QBluetoothUuid__WeightScaleFeature = QBluetoothUuid__CharacteristicType(0x2a9e)
QBluetoothUuid__UserControlPoint = QBluetoothUuid__CharacteristicType(0x2a9f)
QBluetoothUuid__MagneticFluxDensity2D = QBluetoothUuid__CharacteristicType(0x2aa0)
QBluetoothUuid__MagneticFluxDensity3D = QBluetoothUuid__CharacteristicType(0x2aa1)
QBluetoothUuid__Language = QBluetoothUuid__CharacteristicType(0x2aa2)
QBluetoothUuid__BarometricPressureTrend = QBluetoothUuid__CharacteristicType(0x2aa3)
)
//QBluetoothUuid::DescriptorType
type QBluetoothUuid__DescriptorType int
var (
QBluetoothUuid__UnknownDescriptorType = QBluetoothUuid__DescriptorType(0x0)
QBluetoothUuid__CharacteristicExtendedProperties = QBluetoothUuid__DescriptorType(0x2900)
QBluetoothUuid__CharacteristicUserDescription = QBluetoothUuid__DescriptorType(0x2901)
QBluetoothUuid__ClientCharacteristicConfiguration = QBluetoothUuid__DescriptorType(0x2902)
QBluetoothUuid__ServerCharacteristicConfiguration = QBluetoothUuid__DescriptorType(0x2903)
QBluetoothUuid__CharacteristicPresentationFormat = QBluetoothUuid__DescriptorType(0x2904)
QBluetoothUuid__CharacteristicAggregateFormat = QBluetoothUuid__DescriptorType(0x2905)
QBluetoothUuid__ValidRange = QBluetoothUuid__DescriptorType(0x2906)
QBluetoothUuid__ExternalReportReference = QBluetoothUuid__DescriptorType(0x2907)
QBluetoothUuid__ReportReference = QBluetoothUuid__DescriptorType(0x2908)
QBluetoothUuid__EnvironmentalSensingConfiguration = QBluetoothUuid__DescriptorType(0x290b)
QBluetoothUuid__EnvironmentalSensingMeasurement = QBluetoothUuid__DescriptorType(0x290c)
QBluetoothUuid__EnvironmentalSensingTriggerSetting = QBluetoothUuid__DescriptorType(0x290d)
)
//QBluetoothUuid::ProtocolUuid
type QBluetoothUuid__ProtocolUuid int
var (
QBluetoothUuid__Sdp = QBluetoothUuid__ProtocolUuid(0x0001)
QBluetoothUuid__Udp = QBluetoothUuid__ProtocolUuid(0x0002)
QBluetoothUuid__Rfcomm = QBluetoothUuid__ProtocolUuid(0x0003)
QBluetoothUuid__Tcp = QBluetoothUuid__ProtocolUuid(0x0004)
QBluetoothUuid__TcsBin = QBluetoothUuid__ProtocolUuid(0x0005)
QBluetoothUuid__TcsAt = QBluetoothUuid__ProtocolUuid(0x0006)
QBluetoothUuid__Att = QBluetoothUuid__ProtocolUuid(0x0007)
QBluetoothUuid__Obex = QBluetoothUuid__ProtocolUuid(0x0008)
QBluetoothUuid__Ip = QBluetoothUuid__ProtocolUuid(0x0009)
QBluetoothUuid__Ftp = QBluetoothUuid__ProtocolUuid(0x000A)
QBluetoothUuid__Http = QBluetoothUuid__ProtocolUuid(0x000C)
QBluetoothUuid__Wsp = QBluetoothUuid__ProtocolUuid(0x000E)
QBluetoothUuid__Bnep = QBluetoothUuid__ProtocolUuid(0x000F)
QBluetoothUuid__Upnp = QBluetoothUuid__ProtocolUuid(0x0010)
QBluetoothUuid__Hidp = QBluetoothUuid__ProtocolUuid(0x0011)
QBluetoothUuid__HardcopyControlChannel = QBluetoothUuid__ProtocolUuid(0x0012)
QBluetoothUuid__HardcopyDataChannel = QBluetoothUuid__ProtocolUuid(0x0014)
QBluetoothUuid__HardcopyNotification = QBluetoothUuid__ProtocolUuid(0x0016)
QBluetoothUuid__Avctp = QBluetoothUuid__ProtocolUuid(0x0017)
QBluetoothUuid__Avdtp = QBluetoothUuid__ProtocolUuid(0x0019)
QBluetoothUuid__Cmtp = QBluetoothUuid__ProtocolUuid(0x001B)
QBluetoothUuid__UdiCPlain = QBluetoothUuid__ProtocolUuid(0x001D)
QBluetoothUuid__McapControlChannel = QBluetoothUuid__ProtocolUuid(0x001E)
QBluetoothUuid__McapDataChannel = QBluetoothUuid__ProtocolUuid(0x001F)
QBluetoothUuid__L2cap = QBluetoothUuid__ProtocolUuid(0x0100)
)
//QBluetoothUuid::ServiceClassUuid
type QBluetoothUuid__ServiceClassUuid int
var (
QBluetoothUuid__ServiceDiscoveryServer = QBluetoothUuid__ServiceClassUuid(0x1000)
QBluetoothUuid__BrowseGroupDescriptor = QBluetoothUuid__ServiceClassUuid(0x1001)
QBluetoothUuid__PublicBrowseGroup = QBluetoothUuid__ServiceClassUuid(0x1002)
QBluetoothUuid__SerialPort = QBluetoothUuid__ServiceClassUuid(0x1101)
QBluetoothUuid__LANAccessUsingPPP = QBluetoothUuid__ServiceClassUuid(0x1102)
QBluetoothUuid__DialupNetworking = QBluetoothUuid__ServiceClassUuid(0x1103)
QBluetoothUuid__IrMCSync = QBluetoothUuid__ServiceClassUuid(0x1104)
QBluetoothUuid__ObexObjectPush = QBluetoothUuid__ServiceClassUuid(0x1105)
QBluetoothUuid__OBEXFileTransfer = QBluetoothUuid__ServiceClassUuid(0x1106)
QBluetoothUuid__IrMCSyncCommand = QBluetoothUuid__ServiceClassUuid(0x1107)
QBluetoothUuid__Headset = QBluetoothUuid__ServiceClassUuid(0x1108)
QBluetoothUuid__AudioSource = QBluetoothUuid__ServiceClassUuid(0x110a)
QBluetoothUuid__AudioSink = QBluetoothUuid__ServiceClassUuid(0x110b)
QBluetoothUuid__AV_RemoteControlTarget = QBluetoothUuid__ServiceClassUuid(0x110c)
QBluetoothUuid__AdvancedAudioDistribution = QBluetoothUuid__ServiceClassUuid(0x110d)
QBluetoothUuid__AV_RemoteControl = QBluetoothUuid__ServiceClassUuid(0x110e)
QBluetoothUuid__AV_RemoteControlController = QBluetoothUuid__ServiceClassUuid(0x110f)
QBluetoothUuid__HeadsetAG = QBluetoothUuid__ServiceClassUuid(0x1112)
QBluetoothUuid__PANU = QBluetoothUuid__ServiceClassUuid(0x1115)
QBluetoothUuid__NAP = QBluetoothUuid__ServiceClassUuid(0x1116)
QBluetoothUuid__GN = QBluetoothUuid__ServiceClassUuid(0x1117)
QBluetoothUuid__DirectPrinting = QBluetoothUuid__ServiceClassUuid(0x1118)
QBluetoothUuid__ReferencePrinting = QBluetoothUuid__ServiceClassUuid(0x1119)
QBluetoothUuid__BasicImage = QBluetoothUuid__ServiceClassUuid(0x111a)
QBluetoothUuid__ImagingResponder = QBluetoothUuid__ServiceClassUuid(0x111b)
QBluetoothUuid__ImagingAutomaticArchive = QBluetoothUuid__ServiceClassUuid(0x111c)
QBluetoothUuid__ImagingReferenceObjects = QBluetoothUuid__ServiceClassUuid(0x111d)
QBluetoothUuid__Handsfree = QBluetoothUuid__ServiceClassUuid(0x111e)
QBluetoothUuid__HandsfreeAudioGateway = QBluetoothUuid__ServiceClassUuid(0x111f)
QBluetoothUuid__DirectPrintingReferenceObjectsService = QBluetoothUuid__ServiceClassUuid(0x1120)
QBluetoothUuid__ReflectedUI = QBluetoothUuid__ServiceClassUuid(0x1121)
QBluetoothUuid__BasicPrinting = QBluetoothUuid__ServiceClassUuid(0x1122)
QBluetoothUuid__PrintingStatus = QBluetoothUuid__ServiceClassUuid(0x1123)
QBluetoothUuid__HumanInterfaceDeviceService = QBluetoothUuid__ServiceClassUuid(0x1124)
QBluetoothUuid__HardcopyCableReplacement = QBluetoothUuid__ServiceClassUuid(0x1125)
QBluetoothUuid__HCRPrint = QBluetoothUuid__ServiceClassUuid(0x1126)
QBluetoothUuid__HCRScan = QBluetoothUuid__ServiceClassUuid(0x1127)
QBluetoothUuid__SIMAccess = QBluetoothUuid__ServiceClassUuid(0x112d)
QBluetoothUuid__PhonebookAccessPCE = QBluetoothUuid__ServiceClassUuid(0x112e)
QBluetoothUuid__PhonebookAccessPSE = QBluetoothUuid__ServiceClassUuid(0x112f)
QBluetoothUuid__PhonebookAccess = QBluetoothUuid__ServiceClassUuid(0x1130)
QBluetoothUuid__HeadsetHS = QBluetoothUuid__ServiceClassUuid(0x1131)
QBluetoothUuid__MessageAccessServer = QBluetoothUuid__ServiceClassUuid(0x1132)
QBluetoothUuid__MessageNotificationServer = QBluetoothUuid__ServiceClassUuid(0x1133)
QBluetoothUuid__MessageAccessProfile = QBluetoothUuid__ServiceClassUuid(0x1134)
QBluetoothUuid__GNSS = QBluetoothUuid__ServiceClassUuid(0x1135)
QBluetoothUuid__GNSSServer = QBluetoothUuid__ServiceClassUuid(0x1136)
QBluetoothUuid__Display3D = QBluetoothUuid__ServiceClassUuid(0x1137)
QBluetoothUuid__Glasses3D = QBluetoothUuid__ServiceClassUuid(0x1138)
QBluetoothUuid__Synchronization3D = QBluetoothUuid__ServiceClassUuid(0x1139)
QBluetoothUuid__MPSProfile = QBluetoothUuid__ServiceClassUuid(0x113a)
QBluetoothUuid__MPSService = QBluetoothUuid__ServiceClassUuid(0x113b)
QBluetoothUuid__PnPInformation = QBluetoothUuid__ServiceClassUuid(0x1200)
QBluetoothUuid__GenericNetworking = QBluetoothUuid__ServiceClassUuid(0x1201)
QBluetoothUuid__GenericFileTransfer = QBluetoothUuid__ServiceClassUuid(0x1202)
QBluetoothUuid__GenericAudio = QBluetoothUuid__ServiceClassUuid(0x1203)
QBluetoothUuid__GenericTelephony = QBluetoothUuid__ServiceClassUuid(0x1204)
QBluetoothUuid__VideoSource = QBluetoothUuid__ServiceClassUuid(0x1303)
QBluetoothUuid__VideoSink = QBluetoothUuid__ServiceClassUuid(0x1304)
QBluetoothUuid__VideoDistribution = QBluetoothUuid__ServiceClassUuid(0x1305)
QBluetoothUuid__HDP = QBluetoothUuid__ServiceClassUuid(0x1400)
QBluetoothUuid__HDPSource = QBluetoothUuid__ServiceClassUuid(0x1401)
QBluetoothUuid__HDPSink = QBluetoothUuid__ServiceClassUuid(0x1402)
QBluetoothUuid__GenericAccess = QBluetoothUuid__ServiceClassUuid(0x1800)
QBluetoothUuid__GenericAttribute = QBluetoothUuid__ServiceClassUuid(0x1801)
QBluetoothUuid__ImmediateAlert = QBluetoothUuid__ServiceClassUuid(0x1802)
QBluetoothUuid__LinkLoss = QBluetoothUuid__ServiceClassUuid(0x1803)
QBluetoothUuid__TxPower = QBluetoothUuid__ServiceClassUuid(0x1804)
QBluetoothUuid__CurrentTimeService = QBluetoothUuid__ServiceClassUuid(0x1805)
QBluetoothUuid__ReferenceTimeUpdateService = QBluetoothUuid__ServiceClassUuid(0x1806)
QBluetoothUuid__NextDSTChangeService = QBluetoothUuid__ServiceClassUuid(0x1807)
QBluetoothUuid__Glucose = QBluetoothUuid__ServiceClassUuid(0x1808)
QBluetoothUuid__HealthThermometer = QBluetoothUuid__ServiceClassUuid(0x1809)
QBluetoothUuid__DeviceInformation = QBluetoothUuid__ServiceClassUuid(0x180a)
QBluetoothUuid__HeartRate = QBluetoothUuid__ServiceClassUuid(0x180d)
QBluetoothUuid__PhoneAlertStatusService = QBluetoothUuid__ServiceClassUuid(0x180e)
QBluetoothUuid__BatteryService = QBluetoothUuid__ServiceClassUuid(0x180f)
QBluetoothUuid__BloodPressure = QBluetoothUuid__ServiceClassUuid(0x1810)
QBluetoothUuid__AlertNotificationService = QBluetoothUuid__ServiceClassUuid(0x1811)
QBluetoothUuid__HumanInterfaceDevice = QBluetoothUuid__ServiceClassUuid(0x1812)
QBluetoothUuid__ScanParameters = QBluetoothUuid__ServiceClassUuid(0x1813)
QBluetoothUuid__RunningSpeedAndCadence = QBluetoothUuid__ServiceClassUuid(0x1814)
QBluetoothUuid__CyclingSpeedAndCadence = QBluetoothUuid__ServiceClassUuid(0x1816)
QBluetoothUuid__CyclingPower = QBluetoothUuid__ServiceClassUuid(0x1818)
QBluetoothUuid__LocationAndNavigation = QBluetoothUuid__ServiceClassUuid(0x1819)
QBluetoothUuid__EnvironmentalSensing = QBluetoothUuid__ServiceClassUuid(0x181a)
QBluetoothUuid__BodyComposition = QBluetoothUuid__ServiceClassUuid(0x181b)
QBluetoothUuid__UserData = QBluetoothUuid__ServiceClassUuid(0x181c)
QBluetoothUuid__WeightScale = QBluetoothUuid__ServiceClassUuid(0x181d)
QBluetoothUuid__BondManagement = QBluetoothUuid__ServiceClassUuid(0x181e)
QBluetoothUuid__ContinuousGlucoseMonitoring = QBluetoothUuid__ServiceClassUuid(0x181f)
)
func NewQBluetoothUuid() *QBluetoothUuid {
return QBluetoothUuidFromPointer(unsafe.Pointer(C.QBluetoothUuid_NewQBluetoothUuid()))
}
func NewQBluetoothUuid4(uuid QBluetoothUuid__CharacteristicType) *QBluetoothUuid {
return QBluetoothUuidFromPointer(unsafe.Pointer(C.QBluetoothUuid_NewQBluetoothUuid4(C.int(uuid))))
}
func NewQBluetoothUuid5(uuid QBluetoothUuid__DescriptorType) *QBluetoothUuid {
return QBluetoothUuidFromPointer(unsafe.Pointer(C.QBluetoothUuid_NewQBluetoothUuid5(C.int(uuid))))
}
func NewQBluetoothUuid2(uuid QBluetoothUuid__ProtocolUuid) *QBluetoothUuid {
return QBluetoothUuidFromPointer(unsafe.Pointer(C.QBluetoothUuid_NewQBluetoothUuid2(C.int(uuid))))
}
func NewQBluetoothUuid3(uuid QBluetoothUuid__ServiceClassUuid) *QBluetoothUuid {
return QBluetoothUuidFromPointer(unsafe.Pointer(C.QBluetoothUuid_NewQBluetoothUuid3(C.int(uuid))))
}
func NewQBluetoothUuid10(uuid QBluetoothUuidITF) *QBluetoothUuid {
return QBluetoothUuidFromPointer(unsafe.Pointer(C.QBluetoothUuid_NewQBluetoothUuid10(C.QtObjectPtr(PointerFromQBluetoothUuid(uuid)))))
}
func NewQBluetoothUuid9(uuid string) *QBluetoothUuid {
return QBluetoothUuidFromPointer(unsafe.Pointer(C.QBluetoothUuid_NewQBluetoothUuid9(C.CString(uuid))))
}
func NewQBluetoothUuid11(uuid core.QUuidITF) *QBluetoothUuid {
return QBluetoothUuidFromPointer(unsafe.Pointer(C.QBluetoothUuid_NewQBluetoothUuid11(C.QtObjectPtr(core.PointerFromQUuid(uuid)))))
}
func QBluetoothUuid_CharacteristicToString(uuid QBluetoothUuid__CharacteristicType) string {
return C.GoString(C.QBluetoothUuid_QBluetoothUuid_CharacteristicToString(C.int(uuid)))
}
func QBluetoothUuid_DescriptorToString(uuid QBluetoothUuid__DescriptorType) string {
return C.GoString(C.QBluetoothUuid_QBluetoothUuid_DescriptorToString(C.int(uuid)))
}
func (ptr *QBluetoothUuid) MinimumSize() int {
if ptr.Pointer() != nil {
return int(C.QBluetoothUuid_MinimumSize(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func QBluetoothUuid_ProtocolToString(uuid QBluetoothUuid__ProtocolUuid) string {
return C.GoString(C.QBluetoothUuid_QBluetoothUuid_ProtocolToString(C.int(uuid)))
}
func QBluetoothUuid_ServiceClassToString(uuid QBluetoothUuid__ServiceClassUuid) string {
return C.GoString(C.QBluetoothUuid_QBluetoothUuid_ServiceClassToString(C.int(uuid)))
}
func (ptr *QBluetoothUuid) DestroyQBluetoothUuid() {
if ptr.Pointer() != nil {
C.QBluetoothUuid_DestroyQBluetoothUuid(C.QtObjectPtr(ptr.Pointer()))
}
}

23
bluetooth/qbluetoothuuid.h Executable file
View file

@ -0,0 +1,23 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid();
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid4(int uuid);
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid5(int uuid);
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid2(int uuid);
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid3(int uuid);
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid10(QtObjectPtr uuid);
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid9(char* uuid);
QtObjectPtr QBluetoothUuid_NewQBluetoothUuid11(QtObjectPtr uuid);
char* QBluetoothUuid_QBluetoothUuid_CharacteristicToString(int uuid);
char* QBluetoothUuid_QBluetoothUuid_DescriptorToString(int uuid);
int QBluetoothUuid_MinimumSize(QtObjectPtr ptr);
char* QBluetoothUuid_QBluetoothUuid_ProtocolToString(int uuid);
char* QBluetoothUuid_QBluetoothUuid_ServiceClassToString(int uuid);
void QBluetoothUuid_DestroyQBluetoothUuid(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

36
bluetooth/qlowenergycharacteristic.cpp Executable file
View file

@ -0,0 +1,36 @@
#include "qlowenergycharacteristic.h"
#include <QUrl>
#include <QModelIndex>
#include <QString>
#include <QVariant>
#include <QLowEnergyCharacteristic>
#include "_cgo_export.h"
class MyQLowEnergyCharacteristic: public QLowEnergyCharacteristic {
public:
};
QtObjectPtr QLowEnergyCharacteristic_NewQLowEnergyCharacteristic(){
return new QLowEnergyCharacteristic();
}
QtObjectPtr QLowEnergyCharacteristic_NewQLowEnergyCharacteristic2(QtObjectPtr other){
return new QLowEnergyCharacteristic(*static_cast<QLowEnergyCharacteristic*>(other));
}
int QLowEnergyCharacteristic_IsValid(QtObjectPtr ptr){
return static_cast<QLowEnergyCharacteristic*>(ptr)->isValid();
}
char* QLowEnergyCharacteristic_Name(QtObjectPtr ptr){
return static_cast<QLowEnergyCharacteristic*>(ptr)->name().toUtf8().data();
}
int QLowEnergyCharacteristic_Properties(QtObjectPtr ptr){
return static_cast<QLowEnergyCharacteristic*>(ptr)->properties();
}
void QLowEnergyCharacteristic_DestroyQLowEnergyCharacteristic(QtObjectPtr ptr){
static_cast<QLowEnergyCharacteristic*>(ptr)->~QLowEnergyCharacteristic();
}

90
bluetooth/qlowenergycharacteristic.go Executable file
View file

@ -0,0 +1,90 @@
package bluetooth
//#include "qlowenergycharacteristic.h"
import "C"
import (
"unsafe"
)
type QLowEnergyCharacteristic struct {
ptr unsafe.Pointer
}
type QLowEnergyCharacteristicITF interface {
QLowEnergyCharacteristicPTR() *QLowEnergyCharacteristic
}
func (p *QLowEnergyCharacteristic) Pointer() unsafe.Pointer {
return p.ptr
}
func (p *QLowEnergyCharacteristic) SetPointer(ptr unsafe.Pointer) {
p.ptr = ptr
}
func PointerFromQLowEnergyCharacteristic(ptr QLowEnergyCharacteristicITF) unsafe.Pointer {
if ptr != nil {
return ptr.QLowEnergyCharacteristicPTR().Pointer()
}
return nil
}
func QLowEnergyCharacteristicFromPointer(ptr unsafe.Pointer) *QLowEnergyCharacteristic {
var n = new(QLowEnergyCharacteristic)
n.SetPointer(ptr)
return n
}
func (ptr *QLowEnergyCharacteristic) QLowEnergyCharacteristicPTR() *QLowEnergyCharacteristic {
return ptr
}
//QLowEnergyCharacteristic::PropertyType
type QLowEnergyCharacteristic__PropertyType int
var (
QLowEnergyCharacteristic__Unknown = QLowEnergyCharacteristic__PropertyType(0x00)
QLowEnergyCharacteristic__Broadcasting = QLowEnergyCharacteristic__PropertyType(0x01)
QLowEnergyCharacteristic__Read = QLowEnergyCharacteristic__PropertyType(0x02)
QLowEnergyCharacteristic__WriteNoResponse = QLowEnergyCharacteristic__PropertyType(0x04)
QLowEnergyCharacteristic__Write = QLowEnergyCharacteristic__PropertyType(0x08)
QLowEnergyCharacteristic__Notify = QLowEnergyCharacteristic__PropertyType(0x10)
QLowEnergyCharacteristic__Indicate = QLowEnergyCharacteristic__PropertyType(0x20)
QLowEnergyCharacteristic__WriteSigned = QLowEnergyCharacteristic__PropertyType(0x40)
QLowEnergyCharacteristic__ExtendedProperty = QLowEnergyCharacteristic__PropertyType(0x80)
)
func NewQLowEnergyCharacteristic() *QLowEnergyCharacteristic {
return QLowEnergyCharacteristicFromPointer(unsafe.Pointer(C.QLowEnergyCharacteristic_NewQLowEnergyCharacteristic()))
}
func NewQLowEnergyCharacteristic2(other QLowEnergyCharacteristicITF) *QLowEnergyCharacteristic {
return QLowEnergyCharacteristicFromPointer(unsafe.Pointer(C.QLowEnergyCharacteristic_NewQLowEnergyCharacteristic2(C.QtObjectPtr(PointerFromQLowEnergyCharacteristic(other)))))
}
func (ptr *QLowEnergyCharacteristic) IsValid() bool {
if ptr.Pointer() != nil {
return C.QLowEnergyCharacteristic_IsValid(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QLowEnergyCharacteristic) Name() string {
if ptr.Pointer() != nil {
return C.GoString(C.QLowEnergyCharacteristic_Name(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QLowEnergyCharacteristic) Properties() QLowEnergyCharacteristic__PropertyType {
if ptr.Pointer() != nil {
return QLowEnergyCharacteristic__PropertyType(C.QLowEnergyCharacteristic_Properties(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QLowEnergyCharacteristic) DestroyQLowEnergyCharacteristic() {
if ptr.Pointer() != nil {
C.QLowEnergyCharacteristic_DestroyQLowEnergyCharacteristic(C.QtObjectPtr(ptr.Pointer()))
}
}

15
bluetooth/qlowenergycharacteristic.h Executable file
View file

@ -0,0 +1,15 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QLowEnergyCharacteristic_NewQLowEnergyCharacteristic();
QtObjectPtr QLowEnergyCharacteristic_NewQLowEnergyCharacteristic2(QtObjectPtr other);
int QLowEnergyCharacteristic_IsValid(QtObjectPtr ptr);
char* QLowEnergyCharacteristic_Name(QtObjectPtr ptr);
int QLowEnergyCharacteristic_Properties(QtObjectPtr ptr);
void QLowEnergyCharacteristic_DestroyQLowEnergyCharacteristic(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

95
bluetooth/qlowenergycontroller.cpp Executable file
View file

@ -0,0 +1,95 @@
#include "qlowenergycontroller.h"
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QBluetoothUuid>
#include <QObject>
#include <QBluetoothDeviceInfo>
#include <QString>
#include <QLowEnergyController>
#include "_cgo_export.h"
class MyQLowEnergyController: public QLowEnergyController {
public:
void Signal_Connected(){callbackQLowEnergyControllerConnected(this->objectName().toUtf8().data());};
void Signal_Disconnected(){callbackQLowEnergyControllerDisconnected(this->objectName().toUtf8().data());};
void Signal_DiscoveryFinished(){callbackQLowEnergyControllerDiscoveryFinished(this->objectName().toUtf8().data());};
void Signal_StateChanged(QLowEnergyController::ControllerState state){callbackQLowEnergyControllerStateChanged(this->objectName().toUtf8().data(), state);};
};
void QLowEnergyController_ConnectConnected(QtObjectPtr ptr){
QObject::connect(static_cast<QLowEnergyController*>(ptr), static_cast<void (QLowEnergyController::*)()>(&QLowEnergyController::connected), static_cast<MyQLowEnergyController*>(ptr), static_cast<void (MyQLowEnergyController::*)()>(&MyQLowEnergyController::Signal_Connected));;
}
void QLowEnergyController_DisconnectConnected(QtObjectPtr ptr){
QObject::disconnect(static_cast<QLowEnergyController*>(ptr), static_cast<void (QLowEnergyController::*)()>(&QLowEnergyController::connected), static_cast<MyQLowEnergyController*>(ptr), static_cast<void (MyQLowEnergyController::*)()>(&MyQLowEnergyController::Signal_Connected));;
}
void QLowEnergyController_ConnectDisconnected(QtObjectPtr ptr){
QObject::connect(static_cast<QLowEnergyController*>(ptr), static_cast<void (QLowEnergyController::*)()>(&QLowEnergyController::disconnected), static_cast<MyQLowEnergyController*>(ptr), static_cast<void (MyQLowEnergyController::*)()>(&MyQLowEnergyController::Signal_Disconnected));;
}
void QLowEnergyController_DisconnectDisconnected(QtObjectPtr ptr){
QObject::disconnect(static_cast<QLowEnergyController*>(ptr), static_cast<void (QLowEnergyController::*)()>(&QLowEnergyController::disconnected), static_cast<MyQLowEnergyController*>(ptr), static_cast<void (MyQLowEnergyController::*)()>(&MyQLowEnergyController::Signal_Disconnected));;
}
void QLowEnergyController_ConnectDiscoveryFinished(QtObjectPtr ptr){
QObject::connect(static_cast<QLowEnergyController*>(ptr), static_cast<void (QLowEnergyController::*)()>(&QLowEnergyController::discoveryFinished), static_cast<MyQLowEnergyController*>(ptr), static_cast<void (MyQLowEnergyController::*)()>(&MyQLowEnergyController::Signal_DiscoveryFinished));;
}
void QLowEnergyController_DisconnectDiscoveryFinished(QtObjectPtr ptr){
QObject::disconnect(static_cast<QLowEnergyController*>(ptr), static_cast<void (QLowEnergyController::*)()>(&QLowEnergyController::discoveryFinished), static_cast<MyQLowEnergyController*>(ptr), static_cast<void (MyQLowEnergyController::*)()>(&MyQLowEnergyController::Signal_DiscoveryFinished));;
}
void QLowEnergyController_ConnectStateChanged(QtObjectPtr ptr){
QObject::connect(static_cast<QLowEnergyController*>(ptr), static_cast<void (QLowEnergyController::*)(QLowEnergyController::ControllerState)>(&QLowEnergyController::stateChanged), static_cast<MyQLowEnergyController*>(ptr), static_cast<void (MyQLowEnergyController::*)(QLowEnergyController::ControllerState)>(&MyQLowEnergyController::Signal_StateChanged));;
}
void QLowEnergyController_DisconnectStateChanged(QtObjectPtr ptr){
QObject::disconnect(static_cast<QLowEnergyController*>(ptr), static_cast<void (QLowEnergyController::*)(QLowEnergyController::ControllerState)>(&QLowEnergyController::stateChanged), static_cast<MyQLowEnergyController*>(ptr), static_cast<void (MyQLowEnergyController::*)(QLowEnergyController::ControllerState)>(&MyQLowEnergyController::Signal_StateChanged));;
}
QtObjectPtr QLowEnergyController_NewQLowEnergyController(QtObjectPtr remoteDeviceInfo, QtObjectPtr parent){
return new QLowEnergyController(*static_cast<QBluetoothDeviceInfo*>(remoteDeviceInfo), static_cast<QObject*>(parent));
}
void QLowEnergyController_ConnectToDevice(QtObjectPtr ptr){
static_cast<QLowEnergyController*>(ptr)->connectToDevice();
}
QtObjectPtr QLowEnergyController_CreateServiceObject(QtObjectPtr ptr, QtObjectPtr serviceUuid, QtObjectPtr parent){
return static_cast<QLowEnergyController*>(ptr)->createServiceObject(*static_cast<QBluetoothUuid*>(serviceUuid), static_cast<QObject*>(parent));
}
void QLowEnergyController_DisconnectFromDevice(QtObjectPtr ptr){
static_cast<QLowEnergyController*>(ptr)->disconnectFromDevice();
}
void QLowEnergyController_DiscoverServices(QtObjectPtr ptr){
static_cast<QLowEnergyController*>(ptr)->discoverServices();
}
int QLowEnergyController_Error(QtObjectPtr ptr){
return static_cast<QLowEnergyController*>(ptr)->error();
}
char* QLowEnergyController_ErrorString(QtObjectPtr ptr){
return static_cast<QLowEnergyController*>(ptr)->errorString().toUtf8().data();
}
int QLowEnergyController_RemoteAddressType(QtObjectPtr ptr){
return static_cast<QLowEnergyController*>(ptr)->remoteAddressType();
}
char* QLowEnergyController_RemoteName(QtObjectPtr ptr){
return static_cast<QLowEnergyController*>(ptr)->remoteName().toUtf8().data();
}
void QLowEnergyController_SetRemoteAddressType(QtObjectPtr ptr, int ty){
static_cast<QLowEnergyController*>(ptr)->setRemoteAddressType(static_cast<QLowEnergyController::RemoteAddressType>(ty));
}
void QLowEnergyController_DestroyQLowEnergyController(QtObjectPtr ptr){
static_cast<QLowEnergyController*>(ptr)->~QLowEnergyController();
}

216
bluetooth/qlowenergycontroller.go Executable file
View file

@ -0,0 +1,216 @@
package bluetooth
//#include "qlowenergycontroller.h"
import "C"
import (
"github.com/therecipe/qt"
"github.com/therecipe/qt/core"
"unsafe"
)
type QLowEnergyController struct {
core.QObject
}
type QLowEnergyControllerITF interface {
core.QObjectITF
QLowEnergyControllerPTR() *QLowEnergyController
}
func PointerFromQLowEnergyController(ptr QLowEnergyControllerITF) unsafe.Pointer {
if ptr != nil {
return ptr.QLowEnergyControllerPTR().Pointer()
}
return nil
}
func QLowEnergyControllerFromPointer(ptr unsafe.Pointer) *QLowEnergyController {
var n = new(QLowEnergyController)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QLowEnergyController_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QLowEnergyController) QLowEnergyControllerPTR() *QLowEnergyController {
return ptr
}
//QLowEnergyController::ControllerState
type QLowEnergyController__ControllerState int
var (
QLowEnergyController__UnconnectedState = QLowEnergyController__ControllerState(0)
QLowEnergyController__ConnectingState = QLowEnergyController__ControllerState(1)
QLowEnergyController__ConnectedState = QLowEnergyController__ControllerState(2)
QLowEnergyController__DiscoveringState = QLowEnergyController__ControllerState(3)
QLowEnergyController__DiscoveredState = QLowEnergyController__ControllerState(4)
QLowEnergyController__ClosingState = QLowEnergyController__ControllerState(5)
)
//QLowEnergyController::Error
type QLowEnergyController__Error int
var (
QLowEnergyController__NoError = QLowEnergyController__Error(0)
QLowEnergyController__UnknownError = QLowEnergyController__Error(1)
QLowEnergyController__UnknownRemoteDeviceError = QLowEnergyController__Error(2)
QLowEnergyController__NetworkError = QLowEnergyController__Error(3)
QLowEnergyController__InvalidBluetoothAdapterError = QLowEnergyController__Error(4)
QLowEnergyController__ConnectionError = QLowEnergyController__Error(5)
)
//QLowEnergyController::RemoteAddressType
type QLowEnergyController__RemoteAddressType int
var (
QLowEnergyController__PublicAddress = QLowEnergyController__RemoteAddressType(0)
QLowEnergyController__RandomAddress = QLowEnergyController__RemoteAddressType(1)
)
func (ptr *QLowEnergyController) ConnectConnected(f func()) {
if ptr.Pointer() != nil {
C.QLowEnergyController_ConnectConnected(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "connected", f)
}
}
func (ptr *QLowEnergyController) DisconnectConnected() {
if ptr.Pointer() != nil {
C.QLowEnergyController_DisconnectConnected(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "connected")
}
}
//export callbackQLowEnergyControllerConnected
func callbackQLowEnergyControllerConnected(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "connected").(func())()
}
func (ptr *QLowEnergyController) ConnectDisconnected(f func()) {
if ptr.Pointer() != nil {
C.QLowEnergyController_ConnectDisconnected(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "disconnected", f)
}
}
func (ptr *QLowEnergyController) DisconnectDisconnected() {
if ptr.Pointer() != nil {
C.QLowEnergyController_DisconnectDisconnected(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "disconnected")
}
}
//export callbackQLowEnergyControllerDisconnected
func callbackQLowEnergyControllerDisconnected(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "disconnected").(func())()
}
func (ptr *QLowEnergyController) ConnectDiscoveryFinished(f func()) {
if ptr.Pointer() != nil {
C.QLowEnergyController_ConnectDiscoveryFinished(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "discoveryFinished", f)
}
}
func (ptr *QLowEnergyController) DisconnectDiscoveryFinished() {
if ptr.Pointer() != nil {
C.QLowEnergyController_DisconnectDiscoveryFinished(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "discoveryFinished")
}
}
//export callbackQLowEnergyControllerDiscoveryFinished
func callbackQLowEnergyControllerDiscoveryFinished(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "discoveryFinished").(func())()
}
func (ptr *QLowEnergyController) ConnectStateChanged(f func(state QLowEnergyController__ControllerState)) {
if ptr.Pointer() != nil {
C.QLowEnergyController_ConnectStateChanged(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "stateChanged", f)
}
}
func (ptr *QLowEnergyController) DisconnectStateChanged() {
if ptr.Pointer() != nil {
C.QLowEnergyController_DisconnectStateChanged(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "stateChanged")
}
}
//export callbackQLowEnergyControllerStateChanged
func callbackQLowEnergyControllerStateChanged(ptrName *C.char, state C.int) {
qt.GetSignal(C.GoString(ptrName), "stateChanged").(func(QLowEnergyController__ControllerState))(QLowEnergyController__ControllerState(state))
}
func NewQLowEnergyController(remoteDeviceInfo QBluetoothDeviceInfoITF, parent core.QObjectITF) *QLowEnergyController {
return QLowEnergyControllerFromPointer(unsafe.Pointer(C.QLowEnergyController_NewQLowEnergyController(C.QtObjectPtr(PointerFromQBluetoothDeviceInfo(remoteDeviceInfo)), C.QtObjectPtr(core.PointerFromQObject(parent)))))
}
func (ptr *QLowEnergyController) ConnectToDevice() {
if ptr.Pointer() != nil {
C.QLowEnergyController_ConnectToDevice(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QLowEnergyController) CreateServiceObject(serviceUuid QBluetoothUuidITF, parent core.QObjectITF) *QLowEnergyService {
if ptr.Pointer() != nil {
return QLowEnergyServiceFromPointer(unsafe.Pointer(C.QLowEnergyController_CreateServiceObject(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQBluetoothUuid(serviceUuid)), C.QtObjectPtr(core.PointerFromQObject(parent)))))
}
return nil
}
func (ptr *QLowEnergyController) DisconnectFromDevice() {
if ptr.Pointer() != nil {
C.QLowEnergyController_DisconnectFromDevice(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QLowEnergyController) DiscoverServices() {
if ptr.Pointer() != nil {
C.QLowEnergyController_DiscoverServices(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QLowEnergyController) Error() QLowEnergyController__Error {
if ptr.Pointer() != nil {
return QLowEnergyController__Error(C.QLowEnergyController_Error(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QLowEnergyController) ErrorString() string {
if ptr.Pointer() != nil {
return C.GoString(C.QLowEnergyController_ErrorString(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QLowEnergyController) RemoteAddressType() QLowEnergyController__RemoteAddressType {
if ptr.Pointer() != nil {
return QLowEnergyController__RemoteAddressType(C.QLowEnergyController_RemoteAddressType(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QLowEnergyController) RemoteName() string {
if ptr.Pointer() != nil {
return C.GoString(C.QLowEnergyController_RemoteName(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QLowEnergyController) SetRemoteAddressType(ty QLowEnergyController__RemoteAddressType) {
if ptr.Pointer() != nil {
C.QLowEnergyController_SetRemoteAddressType(C.QtObjectPtr(ptr.Pointer()), C.int(ty))
}
}
func (ptr *QLowEnergyController) DestroyQLowEnergyController() {
if ptr.Pointer() != nil {
C.QLowEnergyController_DestroyQLowEnergyController(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

28
bluetooth/qlowenergycontroller.h Executable file
View file

@ -0,0 +1,28 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
void QLowEnergyController_ConnectConnected(QtObjectPtr ptr);
void QLowEnergyController_DisconnectConnected(QtObjectPtr ptr);
void QLowEnergyController_ConnectDisconnected(QtObjectPtr ptr);
void QLowEnergyController_DisconnectDisconnected(QtObjectPtr ptr);
void QLowEnergyController_ConnectDiscoveryFinished(QtObjectPtr ptr);
void QLowEnergyController_DisconnectDiscoveryFinished(QtObjectPtr ptr);
void QLowEnergyController_ConnectStateChanged(QtObjectPtr ptr);
void QLowEnergyController_DisconnectStateChanged(QtObjectPtr ptr);
QtObjectPtr QLowEnergyController_NewQLowEnergyController(QtObjectPtr remoteDeviceInfo, QtObjectPtr parent);
void QLowEnergyController_ConnectToDevice(QtObjectPtr ptr);
QtObjectPtr QLowEnergyController_CreateServiceObject(QtObjectPtr ptr, QtObjectPtr serviceUuid, QtObjectPtr parent);
void QLowEnergyController_DisconnectFromDevice(QtObjectPtr ptr);
void QLowEnergyController_DiscoverServices(QtObjectPtr ptr);
int QLowEnergyController_Error(QtObjectPtr ptr);
char* QLowEnergyController_ErrorString(QtObjectPtr ptr);
int QLowEnergyController_RemoteAddressType(QtObjectPtr ptr);
char* QLowEnergyController_RemoteName(QtObjectPtr ptr);
void QLowEnergyController_SetRemoteAddressType(QtObjectPtr ptr, int ty);
void QLowEnergyController_DestroyQLowEnergyController(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

36
bluetooth/qlowenergydescriptor.cpp Executable file
View file

@ -0,0 +1,36 @@
#include "qlowenergydescriptor.h"
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QLowEnergyDescriptor>
#include "_cgo_export.h"
class MyQLowEnergyDescriptor: public QLowEnergyDescriptor {
public:
};
QtObjectPtr QLowEnergyDescriptor_NewQLowEnergyDescriptor(){
return new QLowEnergyDescriptor();
}
QtObjectPtr QLowEnergyDescriptor_NewQLowEnergyDescriptor2(QtObjectPtr other){
return new QLowEnergyDescriptor(*static_cast<QLowEnergyDescriptor*>(other));
}
int QLowEnergyDescriptor_IsValid(QtObjectPtr ptr){
return static_cast<QLowEnergyDescriptor*>(ptr)->isValid();
}
char* QLowEnergyDescriptor_Name(QtObjectPtr ptr){
return static_cast<QLowEnergyDescriptor*>(ptr)->name().toUtf8().data();
}
int QLowEnergyDescriptor_Type(QtObjectPtr ptr){
return static_cast<QLowEnergyDescriptor*>(ptr)->type();
}
void QLowEnergyDescriptor_DestroyQLowEnergyDescriptor(QtObjectPtr ptr){
static_cast<QLowEnergyDescriptor*>(ptr)->~QLowEnergyDescriptor();
}

75
bluetooth/qlowenergydescriptor.go Executable file
View file

@ -0,0 +1,75 @@
package bluetooth
//#include "qlowenergydescriptor.h"
import "C"
import (
"unsafe"
)
type QLowEnergyDescriptor struct {
ptr unsafe.Pointer
}
type QLowEnergyDescriptorITF interface {
QLowEnergyDescriptorPTR() *QLowEnergyDescriptor
}
func (p *QLowEnergyDescriptor) Pointer() unsafe.Pointer {
return p.ptr
}
func (p *QLowEnergyDescriptor) SetPointer(ptr unsafe.Pointer) {
p.ptr = ptr
}
func PointerFromQLowEnergyDescriptor(ptr QLowEnergyDescriptorITF) unsafe.Pointer {
if ptr != nil {
return ptr.QLowEnergyDescriptorPTR().Pointer()
}
return nil
}
func QLowEnergyDescriptorFromPointer(ptr unsafe.Pointer) *QLowEnergyDescriptor {
var n = new(QLowEnergyDescriptor)
n.SetPointer(ptr)
return n
}
func (ptr *QLowEnergyDescriptor) QLowEnergyDescriptorPTR() *QLowEnergyDescriptor {
return ptr
}
func NewQLowEnergyDescriptor() *QLowEnergyDescriptor {
return QLowEnergyDescriptorFromPointer(unsafe.Pointer(C.QLowEnergyDescriptor_NewQLowEnergyDescriptor()))
}
func NewQLowEnergyDescriptor2(other QLowEnergyDescriptorITF) *QLowEnergyDescriptor {
return QLowEnergyDescriptorFromPointer(unsafe.Pointer(C.QLowEnergyDescriptor_NewQLowEnergyDescriptor2(C.QtObjectPtr(PointerFromQLowEnergyDescriptor(other)))))
}
func (ptr *QLowEnergyDescriptor) IsValid() bool {
if ptr.Pointer() != nil {
return C.QLowEnergyDescriptor_IsValid(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QLowEnergyDescriptor) Name() string {
if ptr.Pointer() != nil {
return C.GoString(C.QLowEnergyDescriptor_Name(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QLowEnergyDescriptor) Type() QBluetoothUuid__DescriptorType {
if ptr.Pointer() != nil {
return QBluetoothUuid__DescriptorType(C.QLowEnergyDescriptor_Type(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QLowEnergyDescriptor) DestroyQLowEnergyDescriptor() {
if ptr.Pointer() != nil {
C.QLowEnergyDescriptor_DestroyQLowEnergyDescriptor(C.QtObjectPtr(ptr.Pointer()))
}
}

15
bluetooth/qlowenergydescriptor.h Executable file
View file

@ -0,0 +1,15 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QLowEnergyDescriptor_NewQLowEnergyDescriptor();
QtObjectPtr QLowEnergyDescriptor_NewQLowEnergyDescriptor2(QtObjectPtr other);
int QLowEnergyDescriptor_IsValid(QtObjectPtr ptr);
char* QLowEnergyDescriptor_Name(QtObjectPtr ptr);
int QLowEnergyDescriptor_Type(QtObjectPtr ptr);
void QLowEnergyDescriptor_DestroyQLowEnergyDescriptor(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

69
bluetooth/qlowenergyservice.cpp Executable file
View file

@ -0,0 +1,69 @@
#include "qlowenergyservice.h"
#include <QObject>
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QLowEnergyCharacteristic>
#include <QByteArray>
#include <QLowEnergyDescriptor>
#include <QLowEnergyService>
#include "_cgo_export.h"
class MyQLowEnergyService: public QLowEnergyService {
public:
void Signal_StateChanged(QLowEnergyService::ServiceState newState){callbackQLowEnergyServiceStateChanged(this->objectName().toUtf8().data(), newState);};
};
void QLowEnergyService_ConnectStateChanged(QtObjectPtr ptr){
QObject::connect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(QLowEnergyService::ServiceState)>(&QLowEnergyService::stateChanged), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(QLowEnergyService::ServiceState)>(&MyQLowEnergyService::Signal_StateChanged));;
}
void QLowEnergyService_DisconnectStateChanged(QtObjectPtr ptr){
QObject::disconnect(static_cast<QLowEnergyService*>(ptr), static_cast<void (QLowEnergyService::*)(QLowEnergyService::ServiceState)>(&QLowEnergyService::stateChanged), static_cast<MyQLowEnergyService*>(ptr), static_cast<void (MyQLowEnergyService::*)(QLowEnergyService::ServiceState)>(&MyQLowEnergyService::Signal_StateChanged));;
}
int QLowEnergyService_Contains(QtObjectPtr ptr, QtObjectPtr characteristic){
return static_cast<QLowEnergyService*>(ptr)->contains(*static_cast<QLowEnergyCharacteristic*>(characteristic));
}
int QLowEnergyService_Contains2(QtObjectPtr ptr, QtObjectPtr descriptor){
return static_cast<QLowEnergyService*>(ptr)->contains(*static_cast<QLowEnergyDescriptor*>(descriptor));
}
void QLowEnergyService_DiscoverDetails(QtObjectPtr ptr){
static_cast<QLowEnergyService*>(ptr)->discoverDetails();
}
int QLowEnergyService_Error(QtObjectPtr ptr){
return static_cast<QLowEnergyService*>(ptr)->error();
}
void QLowEnergyService_ReadCharacteristic(QtObjectPtr ptr, QtObjectPtr characteristic){
static_cast<QLowEnergyService*>(ptr)->readCharacteristic(*static_cast<QLowEnergyCharacteristic*>(characteristic));
}
void QLowEnergyService_ReadDescriptor(QtObjectPtr ptr, QtObjectPtr descriptor){
static_cast<QLowEnergyService*>(ptr)->readDescriptor(*static_cast<QLowEnergyDescriptor*>(descriptor));
}
char* QLowEnergyService_ServiceName(QtObjectPtr ptr){
return static_cast<QLowEnergyService*>(ptr)->serviceName().toUtf8().data();
}
int QLowEnergyService_Type(QtObjectPtr ptr){
return static_cast<QLowEnergyService*>(ptr)->type();
}
void QLowEnergyService_WriteCharacteristic(QtObjectPtr ptr, QtObjectPtr characteristic, QtObjectPtr newValue, int mode){
static_cast<QLowEnergyService*>(ptr)->writeCharacteristic(*static_cast<QLowEnergyCharacteristic*>(characteristic), *static_cast<QByteArray*>(newValue), static_cast<QLowEnergyService::WriteMode>(mode));
}
void QLowEnergyService_WriteDescriptor(QtObjectPtr ptr, QtObjectPtr descriptor, QtObjectPtr newValue){
static_cast<QLowEnergyService*>(ptr)->writeDescriptor(*static_cast<QLowEnergyDescriptor*>(descriptor), *static_cast<QByteArray*>(newValue));
}
void QLowEnergyService_DestroyQLowEnergyService(QtObjectPtr ptr){
static_cast<QLowEnergyService*>(ptr)->~QLowEnergyService();
}

168
bluetooth/qlowenergyservice.go Executable file
View file

@ -0,0 +1,168 @@
package bluetooth
//#include "qlowenergyservice.h"
import "C"
import (
"github.com/therecipe/qt"
"github.com/therecipe/qt/core"
"unsafe"
)
type QLowEnergyService struct {
core.QObject
}
type QLowEnergyServiceITF interface {
core.QObjectITF
QLowEnergyServicePTR() *QLowEnergyService
}
func PointerFromQLowEnergyService(ptr QLowEnergyServiceITF) unsafe.Pointer {
if ptr != nil {
return ptr.QLowEnergyServicePTR().Pointer()
}
return nil
}
func QLowEnergyServiceFromPointer(ptr unsafe.Pointer) *QLowEnergyService {
var n = new(QLowEnergyService)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QLowEnergyService_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QLowEnergyService) QLowEnergyServicePTR() *QLowEnergyService {
return ptr
}
//QLowEnergyService::ServiceError
type QLowEnergyService__ServiceError int
var (
QLowEnergyService__NoError = QLowEnergyService__ServiceError(0)
QLowEnergyService__OperationError = QLowEnergyService__ServiceError(1)
QLowEnergyService__CharacteristicWriteError = QLowEnergyService__ServiceError(2)
QLowEnergyService__DescriptorWriteError = QLowEnergyService__ServiceError(3)
QLowEnergyService__UnknownError = QLowEnergyService__ServiceError(4)
QLowEnergyService__CharacteristicReadError = QLowEnergyService__ServiceError(5)
QLowEnergyService__DescriptorReadError = QLowEnergyService__ServiceError(6)
)
//QLowEnergyService::ServiceState
type QLowEnergyService__ServiceState int
var (
QLowEnergyService__InvalidService = QLowEnergyService__ServiceState(0)
QLowEnergyService__DiscoveryRequired = QLowEnergyService__ServiceState(1)
QLowEnergyService__DiscoveringServices = QLowEnergyService__ServiceState(2)
QLowEnergyService__ServiceDiscovered = QLowEnergyService__ServiceState(3)
)
//QLowEnergyService::ServiceType
type QLowEnergyService__ServiceType int
var (
QLowEnergyService__PrimaryService = QLowEnergyService__ServiceType(0x0001)
QLowEnergyService__IncludedService = QLowEnergyService__ServiceType(0x0002)
)
//QLowEnergyService::WriteMode
type QLowEnergyService__WriteMode int
var (
QLowEnergyService__WriteWithResponse = QLowEnergyService__WriteMode(0)
QLowEnergyService__WriteWithoutResponse = QLowEnergyService__WriteMode(1)
)
func (ptr *QLowEnergyService) ConnectStateChanged(f func(newState QLowEnergyService__ServiceState)) {
if ptr.Pointer() != nil {
C.QLowEnergyService_ConnectStateChanged(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "stateChanged", f)
}
}
func (ptr *QLowEnergyService) DisconnectStateChanged() {
if ptr.Pointer() != nil {
C.QLowEnergyService_DisconnectStateChanged(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "stateChanged")
}
}
//export callbackQLowEnergyServiceStateChanged
func callbackQLowEnergyServiceStateChanged(ptrName *C.char, newState C.int) {
qt.GetSignal(C.GoString(ptrName), "stateChanged").(func(QLowEnergyService__ServiceState))(QLowEnergyService__ServiceState(newState))
}
func (ptr *QLowEnergyService) Contains(characteristic QLowEnergyCharacteristicITF) bool {
if ptr.Pointer() != nil {
return C.QLowEnergyService_Contains(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQLowEnergyCharacteristic(characteristic))) != 0
}
return false
}
func (ptr *QLowEnergyService) Contains2(descriptor QLowEnergyDescriptorITF) bool {
if ptr.Pointer() != nil {
return C.QLowEnergyService_Contains2(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQLowEnergyDescriptor(descriptor))) != 0
}
return false
}
func (ptr *QLowEnergyService) DiscoverDetails() {
if ptr.Pointer() != nil {
C.QLowEnergyService_DiscoverDetails(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QLowEnergyService) Error() QLowEnergyService__ServiceError {
if ptr.Pointer() != nil {
return QLowEnergyService__ServiceError(C.QLowEnergyService_Error(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QLowEnergyService) ReadCharacteristic(characteristic QLowEnergyCharacteristicITF) {
if ptr.Pointer() != nil {
C.QLowEnergyService_ReadCharacteristic(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQLowEnergyCharacteristic(characteristic)))
}
}
func (ptr *QLowEnergyService) ReadDescriptor(descriptor QLowEnergyDescriptorITF) {
if ptr.Pointer() != nil {
C.QLowEnergyService_ReadDescriptor(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQLowEnergyDescriptor(descriptor)))
}
}
func (ptr *QLowEnergyService) ServiceName() string {
if ptr.Pointer() != nil {
return C.GoString(C.QLowEnergyService_ServiceName(C.QtObjectPtr(ptr.Pointer())))
}
return ""
}
func (ptr *QLowEnergyService) Type() QLowEnergyService__ServiceType {
if ptr.Pointer() != nil {
return QLowEnergyService__ServiceType(C.QLowEnergyService_Type(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QLowEnergyService) WriteCharacteristic(characteristic QLowEnergyCharacteristicITF, newValue core.QByteArrayITF, mode QLowEnergyService__WriteMode) {
if ptr.Pointer() != nil {
C.QLowEnergyService_WriteCharacteristic(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQLowEnergyCharacteristic(characteristic)), C.QtObjectPtr(core.PointerFromQByteArray(newValue)), C.int(mode))
}
}
func (ptr *QLowEnergyService) WriteDescriptor(descriptor QLowEnergyDescriptorITF, newValue core.QByteArrayITF) {
if ptr.Pointer() != nil {
C.QLowEnergyService_WriteDescriptor(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQLowEnergyDescriptor(descriptor)), C.QtObjectPtr(core.PointerFromQByteArray(newValue)))
}
}
func (ptr *QLowEnergyService) DestroyQLowEnergyService() {
if ptr.Pointer() != nil {
C.QLowEnergyService_DestroyQLowEnergyService(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

22
bluetooth/qlowenergyservice.h Executable file
View file

@ -0,0 +1,22 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
void QLowEnergyService_ConnectStateChanged(QtObjectPtr ptr);
void QLowEnergyService_DisconnectStateChanged(QtObjectPtr ptr);
int QLowEnergyService_Contains(QtObjectPtr ptr, QtObjectPtr characteristic);
int QLowEnergyService_Contains2(QtObjectPtr ptr, QtObjectPtr descriptor);
void QLowEnergyService_DiscoverDetails(QtObjectPtr ptr);
int QLowEnergyService_Error(QtObjectPtr ptr);
void QLowEnergyService_ReadCharacteristic(QtObjectPtr ptr, QtObjectPtr characteristic);
void QLowEnergyService_ReadDescriptor(QtObjectPtr ptr, QtObjectPtr descriptor);
char* QLowEnergyService_ServiceName(QtObjectPtr ptr);
int QLowEnergyService_Type(QtObjectPtr ptr);
void QLowEnergyService_WriteCharacteristic(QtObjectPtr ptr, QtObjectPtr characteristic, QtObjectPtr newValue, int mode);
void QLowEnergyService_WriteDescriptor(QtObjectPtr ptr, QtObjectPtr descriptor, QtObjectPtr newValue);
void QLowEnergyService_DestroyQLowEnergyService(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

13
cgo_darwin_amd64.go
View file

@ -1,13 +0,0 @@
package qt
/*
#cgo CPPFLAGS: -pipe -O2 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.10.sdk -mmacosx-version-min=10.6 -Wall -W
#cgo CPPFLAGS: -DQT_NO_DEBUG -DQT_GUI_LIB -DQT_CORE_LIB -DQT_WIDGETS_LIB
#cgo CPPFLAGS: -I/usr/local/qt/5.4/clang_64/mkspecs/macx-clang -F/usr/local/qt/5.4/clang_64/lib
#cgo CPPFLAGS: -I/usr/local/qt/5.4/clang_64/lib/QtGui.framework/Versions/5/Headers -I/usr/local/qt/5.4/clang_64/lib/QtCore.framework/Versions/5/Headers -I/usr/local/qt/5.4/clang_64/lib/QtWidgets.framework/Versions/5/Headers
#cgo CPPFLAGS: -I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.10.sdk/System/Library/Frameworks/OpenGL.framework/Versions/A/Headers -I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.10.sdk/System/Library/Frameworks/AGL.framework/Headers
#cgo LDFLAGS: -headerpad_max_install_names -Wl,-syslibroot,/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.10.sdk -mmacosx-version-min=10.6
#cgo LDFLAGS: -F/usr/local/qt/5.4/clang_64/lib -framework QtGui -framework QtCore -framework QtWidgets -framework DiskArbitration -framework IOKit -framework OpenGL -framework AGL
*/
import "C"

12
cgo_linux_386.go
View file

@ -1,12 +0,0 @@
package qt
/*
#cgo CPPFLAGS: -pipe -O2 -Wall -W -D_REENTRANT
#cgo CPPFLAGS: -DQT_NO_DEBUG -DQT_GUI_LIB -DQT_CORE_LIB -DQT_WIDGETS_LIB
#cgo CPPFLAGS: -I/usr/local/Qt5.4.0/5.4/gcc/include -I/usr/local/Qt5.4.0/5.4/gcc/mkspecs/linux-g++
#cgo CPPFLAGS: -I/usr/local/Qt5.4.0/5.4/gcc/include/QtGui -I/usr/local/Qt5.4.0/5.4/gcc/include/QtCore -I/usr/local/Qt5.4.0/5.4/gcc/include/QtWidgets
#cgo LDFLAGS: -Wl,-O1 -Wl,-rpath,/usr/local/Qt5.4.0/5.4/gcc -Wl,-rpath,/usr/local/Qt5.4.0/5.4/gcc/lib
#cgo LDFLAGS: -L/usr/local/Qt5.4.0/5.4/gcc/lib -lQt5Gui -lQt5Core -lQt5Widgets -lpthread
*/
import "C"

12
cgo_linux_amd64.go
View file

@ -1,12 +0,0 @@
package qt
/*
#cgo CPPFLAGS: -pipe -O2 -Wall -W -D_REENTRANT
#cgo CPPFLAGS: -DQT_NO_DEBUG -DQT_GUI_LIB -DQT_CORE_LIB -DQT_WIDGETS_LIB
#cgo CPPFLAGS: -I/usr/local/Qt5.4.0/5.4/gcc_64/include -I/usr/local/Qt5.4.0/5.4/gcc_64/mkspecs/linux-g++
#cgo CPPFLAGS: -I/usr/local/Qt5.4.0/5.4/gcc_64/include/QtGui -I/usr/local/Qt5.4.0/5.4/gcc_64/include/QtCore -I/usr/local/Qt5.4.0/5.4/gcc_64/include/QtWidgets
#cgo LDFLAGS: -Wl,-O1 -Wl,-rpath,/usr/local/Qt5.4.0/5.4/gcc_64 -Wl,-rpath,/usr/local/Qt5.4.0/5.4/gcc_64/lib
#cgo LDFLAGS: -L/usr/local/Qt5.4.0/5.4/gcc_64/lib -lQt5Gui -lQt5Core -lQt5Widgets -lpthread
*/
import "C"

12
cgo_windows_386.go
View file

@ -1,12 +0,0 @@
package qt
/*
#cgo CPPFLAGS: -pipe -fno-keep-inline-dllexport -O2 -Wall -Wextra -fexceptions -mthreads
#cgo CPPFLAGS: -DUNICODE -DQT_NO_DEBUG -DQT_GUI_LIB -DQT_CORE_LIB -DQT_WIDGETS_LIB
#cgo CPPFLAGS: -IC:/Qt/Qt5.4.0/5.4/mingw491_32/include -IC:/Qt/Qt5.4.0/5.4/mingw491_32/mkspecs/win32-g++
#cgo CPPFLAGS: -IC:/Qt/Qt5.4.0/5.4/mingw491_32/include/QtGui -IC:/Qt/Qt5.4.0/5.4/mingw491_32/include/QtCore -IC:/Qt/Qt5.4.0/5.4/mingw491_32/include/QtWidgets
#cgo LDFLAGS: -Wl,-s -Wl,-subsystem,windows -mthreads
#cgo LDFLAGS: -LC:/Qt/Qt5.4.0/5.4/mingw491_32/bin -lQt5Gui -lQt5Core -lQt5Widgets
*/
import "C"

3
cgoexport.h
View file

@ -1,3 +0,0 @@
extern "C" {
#include "_cgo_export.h"
}

23
cgoutil.go Normal file → Executable file
View file

@ -9,27 +9,22 @@ import (
"strings"
)
var signalTable = make(map[string]func())
var signalTable = make(map[string]interface{})
func init() { runtime.LockOSThread() }
func connectSignal(name string, signal string, function func()) {
func ConnectSignal(name string, signal string, function interface{}) {
signalTable[name+":"+signal] = function
}
func getSignal(name string, signal string) func() {
func GetSignal(name string, signal string) interface{} {
if signal == "destroyed" {
defer disconnectAllSignals(name)
}
var signalFunction = signalTable[name+":"+signal]
if signalFunction == nil {
return func() {}
}
return signalFunction
return signalTable[name+":"+signal]
}
func disconnectSignal(name string, signal string) {
func DisconnectSignal(name string, signal string) {
delete(signalTable, name+":"+signal)
}
@ -41,7 +36,7 @@ func disconnectAllSignals(name string) {
}
}
func randomIdentifier() string {
func RandomIdentifier() string {
var (
length = 15
b = make([]byte, length)
@ -58,9 +53,9 @@ func DumpSignalTable() {
fmt.Println("************ DUMP-SIGNALTABLE ************")
}
func goBoolToCInt(b bool) C.int {
func GoBoolToInt(b bool) int {
if b {
return C.int(1)
return 1
}
return C.int(0)
return 0
}

2
cgoutil.h Normal file → Executable file
View file

@ -11,4 +11,4 @@ typedef void* QtObjectPtr;
}
#endif
#endif //__QT_CGOUTIL_H__
#endif //__QT_CGOUTIL_H__

13
core/cgo_darwin_amd64.go Executable file
View file

@ -0,0 +1,13 @@
package core
/*
#cgo CPPFLAGS: -pipe -O2 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk -mmacosx-version-min=10.7 -Wall -W
#cgo CPPFLAGS: -DQT_NO_DEBUG -DQT_CORE_LIB
#cgo CPPFLAGS: -I/usr/local/Qt5.5.1/5.5/clang_64/mkspecs/macx-clang -F/usr/local/Qt5.5.1/5.5/clang_64/lib
#cgo CPPFLAGS: -I/usr/local/Qt5.5.1/5.5/clang_64/lib/QtCore.framework/Headers
#cgo CPPFLAGS: -I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/System/Library/Frameworks/OpenGL.framework/Headers -I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/System/Library/Frameworks/AGL.framework/Headers
#cgo LDFLAGS: -headerpad_max_install_names -Wl,-syslibroot,/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk -mmacosx-version-min=10.7
#cgo LDFLAGS: -F/usr/local/Qt5.5.1/5.5/clang_64/lib -framework QtCore -framework DiskArbitration -framework IOKit -framework OpenGL -framework AGL
*/
import "C"

12
core/cgo_linux_386.go Executable file
View file

@ -0,0 +1,12 @@
package core
/*
#cgo CPPFLAGS: -pipe -O2 -Wall -W -D_REENTRANT
#cgo CPPFLAGS: -DQT_NO_DEBUG -DQT_CORE_LIB
#cgo CPPFLAGS: -I/usr/local/Qt5.5.1/5.5/gcc/include -I/usr/local/Qt5.5.1/5.5/gcc/mkspecs/linux-g++
#cgo CPPFLAGS: -I/usr/local/Qt5.5.1/5.5/gcc/include/QtCore
#cgo LDFLAGS: -Wl,-O1 -Wl,-rpath,/usr/local/Qt5.5.1/5.5/gcc -Wl,-rpath,/usr/local/Qt5.5.1/5.5/gcc/lib
#cgo LDFLAGS: -L/usr/local/Qt5.5.1/5.5/gcc/lib -L/usr/lib -lQt5Core -lpthread
*/
import "C"

12
core/cgo_linux_amd64.go Executable file
View file

@ -0,0 +1,12 @@
package core
/*
#cgo CPPFLAGS: -pipe -O2 -Wall -W -D_REENTRANT
#cgo CPPFLAGS: -DQT_NO_DEBUG -DQT_CORE_LIB
#cgo CPPFLAGS: -I/usr/local/Qt5.5.1/5.5/gcc_64/include -I/usr/local/Qt5.5.1/5.5/gcc_64/mkspecs/linux-g++
#cgo CPPFLAGS: -I/usr/local/Qt5.5.1/5.5/gcc_64/include/QtCore
#cgo LDFLAGS: -Wl,-O1 -Wl,-rpath,/usr/local/Qt5.5.1/5.5/gcc_64 -Wl,-rpath,/usr/local/Qt5.5.1/5.5/gcc_64/lib
#cgo LDFLAGS: -L/usr/local/Qt5.5.1/5.5/gcc_64/lib -L/usr/lib64 -lQt5Core -lpthread
*/
import "C"

12
core/cgo_windows_386.go Executable file
View file

@ -0,0 +1,12 @@
package core
/*
#cgo CPPFLAGS: -pipe -fno-keep-inline-dllexport -O2 -Wall -Wextra -fexceptions -mthreads
#cgo CPPFLAGS: -DUNICODE -DQT_NO_DEBUG -DQT_CORE_LIB
#cgo CPPFLAGS: -IC:/Qt/Qt5.5.1/5.5/mingw492_32/include -IC:/Qt/Qt5.5.1/5.5/mingw492_32/mkspecs/win32-g++
#cgo CPPFLAGS: -IC:/Qt/Qt5.5.1/5.5/mingw492_32/include/QtCore
#cgo LDFLAGS: -Wl,-s -Wl,-subsystem,windows -mthreads
#cgo LDFLAGS: -LC:/Qt/Qt5.5.1/5.5/mingw492_32/bin -lQt5Core
*/
import "C"

118
core/qabstractanimation.cpp Executable file
View file

@ -0,0 +1,118 @@
#include "qabstractanimation.h"
#include <QUrl>
#include <QModelIndex>
#include <QMetaObject>
#include <QObject>
#include <QString>
#include <QVariant>
#include <QAbstractAnimation>
#include "_cgo_export.h"
class MyQAbstractAnimation: public QAbstractAnimation {
public:
void Signal_CurrentLoopChanged(int currentLoop){callbackQAbstractAnimationCurrentLoopChanged(this->objectName().toUtf8().data(), currentLoop);};
void Signal_DirectionChanged(QAbstractAnimation::Direction newDirection){callbackQAbstractAnimationDirectionChanged(this->objectName().toUtf8().data(), newDirection);};
void Signal_Finished(){callbackQAbstractAnimationFinished(this->objectName().toUtf8().data());};
void Signal_StateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState){callbackQAbstractAnimationStateChanged(this->objectName().toUtf8().data(), newState, oldState);};
};
int QAbstractAnimation_CurrentLoop(QtObjectPtr ptr){
return static_cast<QAbstractAnimation*>(ptr)->currentLoop();
}
int QAbstractAnimation_CurrentTime(QtObjectPtr ptr){
return static_cast<QAbstractAnimation*>(ptr)->currentTime();
}
int QAbstractAnimation_Direction(QtObjectPtr ptr){
return static_cast<QAbstractAnimation*>(ptr)->direction();
}
int QAbstractAnimation_LoopCount(QtObjectPtr ptr){
return static_cast<QAbstractAnimation*>(ptr)->loopCount();
}
void QAbstractAnimation_SetCurrentTime(QtObjectPtr ptr, int msecs){
QMetaObject::invokeMethod(static_cast<QAbstractAnimation*>(ptr), "setCurrentTime", Q_ARG(int, msecs));
}
void QAbstractAnimation_SetDirection(QtObjectPtr ptr, int direction){
static_cast<QAbstractAnimation*>(ptr)->setDirection(static_cast<QAbstractAnimation::Direction>(direction));
}
void QAbstractAnimation_SetLoopCount(QtObjectPtr ptr, int loopCount){
static_cast<QAbstractAnimation*>(ptr)->setLoopCount(loopCount);
}
void QAbstractAnimation_ConnectCurrentLoopChanged(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)(int)>(&QAbstractAnimation::currentLoopChanged), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)(int)>(&MyQAbstractAnimation::Signal_CurrentLoopChanged));;
}
void QAbstractAnimation_DisconnectCurrentLoopChanged(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)(int)>(&QAbstractAnimation::currentLoopChanged), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)(int)>(&MyQAbstractAnimation::Signal_CurrentLoopChanged));;
}
int QAbstractAnimation_CurrentLoopTime(QtObjectPtr ptr){
return static_cast<QAbstractAnimation*>(ptr)->currentLoopTime();
}
void QAbstractAnimation_ConnectDirectionChanged(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)(QAbstractAnimation::Direction)>(&QAbstractAnimation::directionChanged), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)(QAbstractAnimation::Direction)>(&MyQAbstractAnimation::Signal_DirectionChanged));;
}
void QAbstractAnimation_DisconnectDirectionChanged(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)(QAbstractAnimation::Direction)>(&QAbstractAnimation::directionChanged), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)(QAbstractAnimation::Direction)>(&MyQAbstractAnimation::Signal_DirectionChanged));;
}
int QAbstractAnimation_Duration(QtObjectPtr ptr){
return static_cast<QAbstractAnimation*>(ptr)->duration();
}
void QAbstractAnimation_ConnectFinished(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)()>(&QAbstractAnimation::finished), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)()>(&MyQAbstractAnimation::Signal_Finished));;
}
void QAbstractAnimation_DisconnectFinished(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)()>(&QAbstractAnimation::finished), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)()>(&MyQAbstractAnimation::Signal_Finished));;
}
QtObjectPtr QAbstractAnimation_Group(QtObjectPtr ptr){
return static_cast<QAbstractAnimation*>(ptr)->group();
}
void QAbstractAnimation_Pause(QtObjectPtr ptr){
QMetaObject::invokeMethod(static_cast<QAbstractAnimation*>(ptr), "pause");
}
void QAbstractAnimation_Resume(QtObjectPtr ptr){
QMetaObject::invokeMethod(static_cast<QAbstractAnimation*>(ptr), "resume");
}
void QAbstractAnimation_SetPaused(QtObjectPtr ptr, int paused){
QMetaObject::invokeMethod(static_cast<QAbstractAnimation*>(ptr), "setPaused", Q_ARG(bool, paused != 0));
}
void QAbstractAnimation_Start(QtObjectPtr ptr, int policy){
QMetaObject::invokeMethod(static_cast<QAbstractAnimation*>(ptr), "start", Q_ARG(QAbstractAnimation::DeletionPolicy, static_cast<QAbstractAnimation::DeletionPolicy>(policy)));
}
void QAbstractAnimation_ConnectStateChanged(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)(QAbstractAnimation::State, QAbstractAnimation::State)>(&QAbstractAnimation::stateChanged), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)(QAbstractAnimation::State, QAbstractAnimation::State)>(&MyQAbstractAnimation::Signal_StateChanged));;
}
void QAbstractAnimation_DisconnectStateChanged(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)(QAbstractAnimation::State, QAbstractAnimation::State)>(&QAbstractAnimation::stateChanged), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)(QAbstractAnimation::State, QAbstractAnimation::State)>(&MyQAbstractAnimation::Signal_StateChanged));;
}
void QAbstractAnimation_Stop(QtObjectPtr ptr){
QMetaObject::invokeMethod(static_cast<QAbstractAnimation*>(ptr), "stop");
}
int QAbstractAnimation_TotalDuration(QtObjectPtr ptr){
return static_cast<QAbstractAnimation*>(ptr)->totalDuration();
}
void QAbstractAnimation_DestroyQAbstractAnimation(QtObjectPtr ptr){
static_cast<QAbstractAnimation*>(ptr)->~QAbstractAnimation();
}

249
core/qabstractanimation.go Executable file
View file

@ -0,0 +1,249 @@
package core
//#include "qabstractanimation.h"
import "C"
import (
"github.com/therecipe/qt"
"unsafe"
)
type QAbstractAnimation struct {
QObject
}
type QAbstractAnimationITF interface {
QObjectITF
QAbstractAnimationPTR() *QAbstractAnimation
}
func PointerFromQAbstractAnimation(ptr QAbstractAnimationITF) unsafe.Pointer {
if ptr != nil {
return ptr.QAbstractAnimationPTR().Pointer()
}
return nil
}
func QAbstractAnimationFromPointer(ptr unsafe.Pointer) *QAbstractAnimation {
var n = new(QAbstractAnimation)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QAbstractAnimation_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QAbstractAnimation) QAbstractAnimationPTR() *QAbstractAnimation {
return ptr
}
//QAbstractAnimation::DeletionPolicy
type QAbstractAnimation__DeletionPolicy int
var (
QAbstractAnimation__KeepWhenStopped = QAbstractAnimation__DeletionPolicy(0)
QAbstractAnimation__DeleteWhenStopped = QAbstractAnimation__DeletionPolicy(1)
)
//QAbstractAnimation::Direction
type QAbstractAnimation__Direction int
var (
QAbstractAnimation__Forward = QAbstractAnimation__Direction(0)
QAbstractAnimation__Backward = QAbstractAnimation__Direction(1)
)
//QAbstractAnimation::State
type QAbstractAnimation__State int
var (
QAbstractAnimation__Stopped = QAbstractAnimation__State(0)
QAbstractAnimation__Paused = QAbstractAnimation__State(1)
QAbstractAnimation__Running = QAbstractAnimation__State(2)
)
func (ptr *QAbstractAnimation) CurrentLoop() int {
if ptr.Pointer() != nil {
return int(C.QAbstractAnimation_CurrentLoop(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAbstractAnimation) CurrentTime() int {
if ptr.Pointer() != nil {
return int(C.QAbstractAnimation_CurrentTime(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAbstractAnimation) Direction() QAbstractAnimation__Direction {
if ptr.Pointer() != nil {
return QAbstractAnimation__Direction(C.QAbstractAnimation_Direction(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAbstractAnimation) LoopCount() int {
if ptr.Pointer() != nil {
return int(C.QAbstractAnimation_LoopCount(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAbstractAnimation) SetCurrentTime(msecs int) {
if ptr.Pointer() != nil {
C.QAbstractAnimation_SetCurrentTime(C.QtObjectPtr(ptr.Pointer()), C.int(msecs))
}
}
func (ptr *QAbstractAnimation) SetDirection(direction QAbstractAnimation__Direction) {
if ptr.Pointer() != nil {
C.QAbstractAnimation_SetDirection(C.QtObjectPtr(ptr.Pointer()), C.int(direction))
}
}
func (ptr *QAbstractAnimation) SetLoopCount(loopCount int) {
if ptr.Pointer() != nil {
C.QAbstractAnimation_SetLoopCount(C.QtObjectPtr(ptr.Pointer()), C.int(loopCount))
}
}
func (ptr *QAbstractAnimation) ConnectCurrentLoopChanged(f func(currentLoop int)) {
if ptr.Pointer() != nil {
C.QAbstractAnimation_ConnectCurrentLoopChanged(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "currentLoopChanged", f)
}
}
func (ptr *QAbstractAnimation) DisconnectCurrentLoopChanged() {
if ptr.Pointer() != nil {
C.QAbstractAnimation_DisconnectCurrentLoopChanged(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "currentLoopChanged")
}
}
//export callbackQAbstractAnimationCurrentLoopChanged
func callbackQAbstractAnimationCurrentLoopChanged(ptrName *C.char, currentLoop C.int) {
qt.GetSignal(C.GoString(ptrName), "currentLoopChanged").(func(int))(int(currentLoop))
}
func (ptr *QAbstractAnimation) CurrentLoopTime() int {
if ptr.Pointer() != nil {
return int(C.QAbstractAnimation_CurrentLoopTime(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAbstractAnimation) ConnectDirectionChanged(f func(newDirection QAbstractAnimation__Direction)) {
if ptr.Pointer() != nil {
C.QAbstractAnimation_ConnectDirectionChanged(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "directionChanged", f)
}
}
func (ptr *QAbstractAnimation) DisconnectDirectionChanged() {
if ptr.Pointer() != nil {
C.QAbstractAnimation_DisconnectDirectionChanged(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "directionChanged")
}
}
//export callbackQAbstractAnimationDirectionChanged
func callbackQAbstractAnimationDirectionChanged(ptrName *C.char, newDirection C.int) {
qt.GetSignal(C.GoString(ptrName), "directionChanged").(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(newDirection))
}
func (ptr *QAbstractAnimation) Duration() int {
if ptr.Pointer() != nil {
return int(C.QAbstractAnimation_Duration(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAbstractAnimation) ConnectFinished(f func()) {
if ptr.Pointer() != nil {
C.QAbstractAnimation_ConnectFinished(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "finished", f)
}
}
func (ptr *QAbstractAnimation) DisconnectFinished() {
if ptr.Pointer() != nil {
C.QAbstractAnimation_DisconnectFinished(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "finished")
}
}
//export callbackQAbstractAnimationFinished
func callbackQAbstractAnimationFinished(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "finished").(func())()
}
func (ptr *QAbstractAnimation) Group() *QAnimationGroup {
if ptr.Pointer() != nil {
return QAnimationGroupFromPointer(unsafe.Pointer(C.QAbstractAnimation_Group(C.QtObjectPtr(ptr.Pointer()))))
}
return nil
}
func (ptr *QAbstractAnimation) Pause() {
if ptr.Pointer() != nil {
C.QAbstractAnimation_Pause(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QAbstractAnimation) Resume() {
if ptr.Pointer() != nil {
C.QAbstractAnimation_Resume(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QAbstractAnimation) SetPaused(paused bool) {
if ptr.Pointer() != nil {
C.QAbstractAnimation_SetPaused(C.QtObjectPtr(ptr.Pointer()), C.int(qt.GoBoolToInt(paused)))
}
}
func (ptr *QAbstractAnimation) Start(policy QAbstractAnimation__DeletionPolicy) {
if ptr.Pointer() != nil {
C.QAbstractAnimation_Start(C.QtObjectPtr(ptr.Pointer()), C.int(policy))
}
}
func (ptr *QAbstractAnimation) ConnectStateChanged(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
if ptr.Pointer() != nil {
C.QAbstractAnimation_ConnectStateChanged(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "stateChanged", f)
}
}
func (ptr *QAbstractAnimation) DisconnectStateChanged() {
if ptr.Pointer() != nil {
C.QAbstractAnimation_DisconnectStateChanged(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "stateChanged")
}
}
//export callbackQAbstractAnimationStateChanged
func callbackQAbstractAnimationStateChanged(ptrName *C.char, newState C.int, oldState C.int) {
qt.GetSignal(C.GoString(ptrName), "stateChanged").(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
}
func (ptr *QAbstractAnimation) Stop() {
if ptr.Pointer() != nil {
C.QAbstractAnimation_Stop(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QAbstractAnimation) TotalDuration() int {
if ptr.Pointer() != nil {
return int(C.QAbstractAnimation_TotalDuration(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAbstractAnimation) DestroyQAbstractAnimation() {
if ptr.Pointer() != nil {
C.QAbstractAnimation_DestroyQAbstractAnimation(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

34
core/qabstractanimation.h Executable file
View file

@ -0,0 +1,34 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
int QAbstractAnimation_CurrentLoop(QtObjectPtr ptr);
int QAbstractAnimation_CurrentTime(QtObjectPtr ptr);
int QAbstractAnimation_Direction(QtObjectPtr ptr);
int QAbstractAnimation_LoopCount(QtObjectPtr ptr);
void QAbstractAnimation_SetCurrentTime(QtObjectPtr ptr, int msecs);
void QAbstractAnimation_SetDirection(QtObjectPtr ptr, int direction);
void QAbstractAnimation_SetLoopCount(QtObjectPtr ptr, int loopCount);
void QAbstractAnimation_ConnectCurrentLoopChanged(QtObjectPtr ptr);
void QAbstractAnimation_DisconnectCurrentLoopChanged(QtObjectPtr ptr);
int QAbstractAnimation_CurrentLoopTime(QtObjectPtr ptr);
void QAbstractAnimation_ConnectDirectionChanged(QtObjectPtr ptr);
void QAbstractAnimation_DisconnectDirectionChanged(QtObjectPtr ptr);
int QAbstractAnimation_Duration(QtObjectPtr ptr);
void QAbstractAnimation_ConnectFinished(QtObjectPtr ptr);
void QAbstractAnimation_DisconnectFinished(QtObjectPtr ptr);
QtObjectPtr QAbstractAnimation_Group(QtObjectPtr ptr);
void QAbstractAnimation_Pause(QtObjectPtr ptr);
void QAbstractAnimation_Resume(QtObjectPtr ptr);
void QAbstractAnimation_SetPaused(QtObjectPtr ptr, int paused);
void QAbstractAnimation_Start(QtObjectPtr ptr, int policy);
void QAbstractAnimation_ConnectStateChanged(QtObjectPtr ptr);
void QAbstractAnimation_DisconnectStateChanged(QtObjectPtr ptr);
void QAbstractAnimation_Stop(QtObjectPtr ptr);
int QAbstractAnimation_TotalDuration(QtObjectPtr ptr);
void QAbstractAnimation_DestroyQAbstractAnimation(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

88
core/qabstracteventdispatcher.cpp Executable file
View file

@ -0,0 +1,88 @@
#include "qabstracteventdispatcher.h"
#include <QObject>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QSocketNotifier>
#include <QThread>
#include <QEventLoop>
#include <QAbstractNativeEventFilter>
#include <QEvent>
#include <QString>
#include <QAbstractEventDispatcher>
#include "_cgo_export.h"
class MyQAbstractEventDispatcher: public QAbstractEventDispatcher {
public:
void Signal_AboutToBlock(){callbackQAbstractEventDispatcherAboutToBlock(this->objectName().toUtf8().data());};
void Signal_Awake(){callbackQAbstractEventDispatcherAwake(this->objectName().toUtf8().data());};
};
void QAbstractEventDispatcher_ConnectAboutToBlock(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractEventDispatcher*>(ptr), static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::aboutToBlock), static_cast<MyQAbstractEventDispatcher*>(ptr), static_cast<void (MyQAbstractEventDispatcher::*)()>(&MyQAbstractEventDispatcher::Signal_AboutToBlock));;
}
void QAbstractEventDispatcher_DisconnectAboutToBlock(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractEventDispatcher*>(ptr), static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::aboutToBlock), static_cast<MyQAbstractEventDispatcher*>(ptr), static_cast<void (MyQAbstractEventDispatcher::*)()>(&MyQAbstractEventDispatcher::Signal_AboutToBlock));;
}
void QAbstractEventDispatcher_ConnectAwake(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractEventDispatcher*>(ptr), static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::awake), static_cast<MyQAbstractEventDispatcher*>(ptr), static_cast<void (MyQAbstractEventDispatcher::*)()>(&MyQAbstractEventDispatcher::Signal_Awake));;
}
void QAbstractEventDispatcher_DisconnectAwake(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractEventDispatcher*>(ptr), static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::awake), static_cast<MyQAbstractEventDispatcher*>(ptr), static_cast<void (MyQAbstractEventDispatcher::*)()>(&MyQAbstractEventDispatcher::Signal_Awake));;
}
void QAbstractEventDispatcher_Flush(QtObjectPtr ptr){
static_cast<QAbstractEventDispatcher*>(ptr)->flush();
}
void QAbstractEventDispatcher_InstallNativeEventFilter(QtObjectPtr ptr, QtObjectPtr filterObj){
static_cast<QAbstractEventDispatcher*>(ptr)->installNativeEventFilter(static_cast<QAbstractNativeEventFilter*>(filterObj));
}
QtObjectPtr QAbstractEventDispatcher_QAbstractEventDispatcher_Instance(QtObjectPtr thread){
return QAbstractEventDispatcher::instance(static_cast<QThread*>(thread));
}
void QAbstractEventDispatcher_Interrupt(QtObjectPtr ptr){
static_cast<QAbstractEventDispatcher*>(ptr)->interrupt();
}
int QAbstractEventDispatcher_ProcessEvents(QtObjectPtr ptr, int flags){
return static_cast<QAbstractEventDispatcher*>(ptr)->processEvents(static_cast<QEventLoop::ProcessEventsFlag>(flags));
}
void QAbstractEventDispatcher_RegisterSocketNotifier(QtObjectPtr ptr, QtObjectPtr notifier){
static_cast<QAbstractEventDispatcher*>(ptr)->registerSocketNotifier(static_cast<QSocketNotifier*>(notifier));
}
int QAbstractEventDispatcher_RemainingTime(QtObjectPtr ptr, int timerId){
return static_cast<QAbstractEventDispatcher*>(ptr)->remainingTime(timerId);
}
void QAbstractEventDispatcher_RemoveNativeEventFilter(QtObjectPtr ptr, QtObjectPtr filter){
static_cast<QAbstractEventDispatcher*>(ptr)->removeNativeEventFilter(static_cast<QAbstractNativeEventFilter*>(filter));
}
void QAbstractEventDispatcher_UnregisterSocketNotifier(QtObjectPtr ptr, QtObjectPtr notifier){
static_cast<QAbstractEventDispatcher*>(ptr)->unregisterSocketNotifier(static_cast<QSocketNotifier*>(notifier));
}
int QAbstractEventDispatcher_UnregisterTimer(QtObjectPtr ptr, int timerId){
return static_cast<QAbstractEventDispatcher*>(ptr)->unregisterTimer(timerId);
}
int QAbstractEventDispatcher_UnregisterTimers(QtObjectPtr ptr, QtObjectPtr object){
return static_cast<QAbstractEventDispatcher*>(ptr)->unregisterTimers(static_cast<QObject*>(object));
}
void QAbstractEventDispatcher_WakeUp(QtObjectPtr ptr){
static_cast<QAbstractEventDispatcher*>(ptr)->wakeUp();
}
void QAbstractEventDispatcher_DestroyQAbstractEventDispatcher(QtObjectPtr ptr){
static_cast<QAbstractEventDispatcher*>(ptr)->~QAbstractEventDispatcher();
}

156
core/qabstracteventdispatcher.go Executable file
View file

@ -0,0 +1,156 @@
package core
//#include "qabstracteventdispatcher.h"
import "C"
import (
"github.com/therecipe/qt"
"unsafe"
)
type QAbstractEventDispatcher struct {
QObject
}
type QAbstractEventDispatcherITF interface {
QObjectITF
QAbstractEventDispatcherPTR() *QAbstractEventDispatcher
}
func PointerFromQAbstractEventDispatcher(ptr QAbstractEventDispatcherITF) unsafe.Pointer {
if ptr != nil {
return ptr.QAbstractEventDispatcherPTR().Pointer()
}
return nil
}
func QAbstractEventDispatcherFromPointer(ptr unsafe.Pointer) *QAbstractEventDispatcher {
var n = new(QAbstractEventDispatcher)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QAbstractEventDispatcher_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QAbstractEventDispatcher) QAbstractEventDispatcherPTR() *QAbstractEventDispatcher {
return ptr
}
func (ptr *QAbstractEventDispatcher) ConnectAboutToBlock(f func()) {
if ptr.Pointer() != nil {
C.QAbstractEventDispatcher_ConnectAboutToBlock(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "aboutToBlock", f)
}
}
func (ptr *QAbstractEventDispatcher) DisconnectAboutToBlock() {
if ptr.Pointer() != nil {
C.QAbstractEventDispatcher_DisconnectAboutToBlock(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "aboutToBlock")
}
}
//export callbackQAbstractEventDispatcherAboutToBlock
func callbackQAbstractEventDispatcherAboutToBlock(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "aboutToBlock").(func())()
}
func (ptr *QAbstractEventDispatcher) ConnectAwake(f func()) {
if ptr.Pointer() != nil {
C.QAbstractEventDispatcher_ConnectAwake(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "awake", f)
}
}
func (ptr *QAbstractEventDispatcher) DisconnectAwake() {
if ptr.Pointer() != nil {
C.QAbstractEventDispatcher_DisconnectAwake(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "awake")
}
}
//export callbackQAbstractEventDispatcherAwake
func callbackQAbstractEventDispatcherAwake(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "awake").(func())()
}
func (ptr *QAbstractEventDispatcher) Flush() {
if ptr.Pointer() != nil {
C.QAbstractEventDispatcher_Flush(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QAbstractEventDispatcher) InstallNativeEventFilter(filterObj QAbstractNativeEventFilterITF) {
if ptr.Pointer() != nil {
C.QAbstractEventDispatcher_InstallNativeEventFilter(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQAbstractNativeEventFilter(filterObj)))
}
}
func QAbstractEventDispatcher_Instance(thread QThreadITF) *QAbstractEventDispatcher {
return QAbstractEventDispatcherFromPointer(unsafe.Pointer(C.QAbstractEventDispatcher_QAbstractEventDispatcher_Instance(C.QtObjectPtr(PointerFromQThread(thread)))))
}
func (ptr *QAbstractEventDispatcher) Interrupt() {
if ptr.Pointer() != nil {
C.QAbstractEventDispatcher_Interrupt(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QAbstractEventDispatcher) ProcessEvents(flags QEventLoop__ProcessEventsFlag) bool {
if ptr.Pointer() != nil {
return C.QAbstractEventDispatcher_ProcessEvents(C.QtObjectPtr(ptr.Pointer()), C.int(flags)) != 0
}
return false
}
func (ptr *QAbstractEventDispatcher) RegisterSocketNotifier(notifier QSocketNotifierITF) {
if ptr.Pointer() != nil {
C.QAbstractEventDispatcher_RegisterSocketNotifier(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQSocketNotifier(notifier)))
}
}
func (ptr *QAbstractEventDispatcher) RemainingTime(timerId int) int {
if ptr.Pointer() != nil {
return int(C.QAbstractEventDispatcher_RemainingTime(C.QtObjectPtr(ptr.Pointer()), C.int(timerId)))
}
return 0
}
func (ptr *QAbstractEventDispatcher) RemoveNativeEventFilter(filter QAbstractNativeEventFilterITF) {
if ptr.Pointer() != nil {
C.QAbstractEventDispatcher_RemoveNativeEventFilter(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQAbstractNativeEventFilter(filter)))
}
}
func (ptr *QAbstractEventDispatcher) UnregisterSocketNotifier(notifier QSocketNotifierITF) {
if ptr.Pointer() != nil {
C.QAbstractEventDispatcher_UnregisterSocketNotifier(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQSocketNotifier(notifier)))
}
}
func (ptr *QAbstractEventDispatcher) UnregisterTimer(timerId int) bool {
if ptr.Pointer() != nil {
return C.QAbstractEventDispatcher_UnregisterTimer(C.QtObjectPtr(ptr.Pointer()), C.int(timerId)) != 0
}
return false
}
func (ptr *QAbstractEventDispatcher) UnregisterTimers(object QObjectITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractEventDispatcher_UnregisterTimers(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQObject(object))) != 0
}
return false
}
func (ptr *QAbstractEventDispatcher) WakeUp() {
if ptr.Pointer() != nil {
C.QAbstractEventDispatcher_WakeUp(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QAbstractEventDispatcher) DestroyQAbstractEventDispatcher() {
if ptr.Pointer() != nil {
C.QAbstractEventDispatcher_DestroyQAbstractEventDispatcher(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

26
core/qabstracteventdispatcher.h Executable file
View file

@ -0,0 +1,26 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
void QAbstractEventDispatcher_ConnectAboutToBlock(QtObjectPtr ptr);
void QAbstractEventDispatcher_DisconnectAboutToBlock(QtObjectPtr ptr);
void QAbstractEventDispatcher_ConnectAwake(QtObjectPtr ptr);
void QAbstractEventDispatcher_DisconnectAwake(QtObjectPtr ptr);
void QAbstractEventDispatcher_Flush(QtObjectPtr ptr);
void QAbstractEventDispatcher_InstallNativeEventFilter(QtObjectPtr ptr, QtObjectPtr filterObj);
QtObjectPtr QAbstractEventDispatcher_QAbstractEventDispatcher_Instance(QtObjectPtr thread);
void QAbstractEventDispatcher_Interrupt(QtObjectPtr ptr);
int QAbstractEventDispatcher_ProcessEvents(QtObjectPtr ptr, int flags);
void QAbstractEventDispatcher_RegisterSocketNotifier(QtObjectPtr ptr, QtObjectPtr notifier);
int QAbstractEventDispatcher_RemainingTime(QtObjectPtr ptr, int timerId);
void QAbstractEventDispatcher_RemoveNativeEventFilter(QtObjectPtr ptr, QtObjectPtr filter);
void QAbstractEventDispatcher_UnregisterSocketNotifier(QtObjectPtr ptr, QtObjectPtr notifier);
int QAbstractEventDispatcher_UnregisterTimer(QtObjectPtr ptr, int timerId);
int QAbstractEventDispatcher_UnregisterTimers(QtObjectPtr ptr, QtObjectPtr object);
void QAbstractEventDispatcher_WakeUp(QtObjectPtr ptr);
void QAbstractEventDispatcher_DestroyQAbstractEventDispatcher(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

294
core/qabstractitemmodel.cpp Executable file
View file

@ -0,0 +1,294 @@
#include "qabstractitemmodel.h"
#include <QMimeData>
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QMetaObject>
#include <QObject>
#include <QAbstractItemModel>
#include "_cgo_export.h"
class MyQAbstractItemModel: public QAbstractItemModel {
public:
void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last){callbackQAbstractItemModelColumnsAboutToBeInserted(this->objectName().toUtf8().data(), parent.internalPointer(), first, last);};
void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn){callbackQAbstractItemModelColumnsAboutToBeMoved(this->objectName().toUtf8().data(), sourceParent.internalPointer(), sourceStart, sourceEnd, destinationParent.internalPointer(), destinationColumn);};
void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last){callbackQAbstractItemModelColumnsAboutToBeRemoved(this->objectName().toUtf8().data(), parent.internalPointer(), first, last);};
void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last){callbackQAbstractItemModelColumnsInserted(this->objectName().toUtf8().data(), parent.internalPointer(), first, last);};
void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column){callbackQAbstractItemModelColumnsMoved(this->objectName().toUtf8().data(), parent.internalPointer(), start, end, destination.internalPointer(), column);};
void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last){callbackQAbstractItemModelColumnsRemoved(this->objectName().toUtf8().data(), parent.internalPointer(), first, last);};
void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last){callbackQAbstractItemModelHeaderDataChanged(this->objectName().toUtf8().data(), orientation, first, last);};
void Signal_ModelAboutToBeReset(){callbackQAbstractItemModelModelAboutToBeReset(this->objectName().toUtf8().data());};
void Signal_ModelReset(){callbackQAbstractItemModelModelReset(this->objectName().toUtf8().data());};
void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end){callbackQAbstractItemModelRowsAboutToBeInserted(this->objectName().toUtf8().data(), parent.internalPointer(), start, end);};
void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow){callbackQAbstractItemModelRowsAboutToBeMoved(this->objectName().toUtf8().data(), sourceParent.internalPointer(), sourceStart, sourceEnd, destinationParent.internalPointer(), destinationRow);};
void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last){callbackQAbstractItemModelRowsAboutToBeRemoved(this->objectName().toUtf8().data(), parent.internalPointer(), first, last);};
void Signal_RowsInserted(const QModelIndex & parent, int first, int last){callbackQAbstractItemModelRowsInserted(this->objectName().toUtf8().data(), parent.internalPointer(), first, last);};
void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row){callbackQAbstractItemModelRowsMoved(this->objectName().toUtf8().data(), parent.internalPointer(), start, end, destination.internalPointer(), row);};
void Signal_RowsRemoved(const QModelIndex & parent, int first, int last){callbackQAbstractItemModelRowsRemoved(this->objectName().toUtf8().data(), parent.internalPointer(), first, last);};
};
QtObjectPtr QAbstractItemModel_Sibling(QtObjectPtr ptr, int row, int column, QtObjectPtr index){
return static_cast<QAbstractItemModel*>(ptr)->sibling(row, column, *static_cast<QModelIndex*>(index)).internalPointer();
}
QtObjectPtr QAbstractItemModel_Buddy(QtObjectPtr ptr, QtObjectPtr index){
return static_cast<QAbstractItemModel*>(ptr)->buddy(*static_cast<QModelIndex*>(index)).internalPointer();
}
int QAbstractItemModel_CanDropMimeData(QtObjectPtr ptr, QtObjectPtr data, int action, int row, int column, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
int QAbstractItemModel_CanFetchMore(QtObjectPtr ptr, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->canFetchMore(*static_cast<QModelIndex*>(parent));
}
int QAbstractItemModel_ColumnCount(QtObjectPtr ptr, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}
void QAbstractItemModel_ConnectColumnsAboutToBeInserted(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsAboutToBeInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsAboutToBeInserted));;
}
void QAbstractItemModel_DisconnectColumnsAboutToBeInserted(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsAboutToBeInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsAboutToBeInserted));;
}
void QAbstractItemModel_ConnectColumnsAboutToBeMoved(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsAboutToBeMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_ColumnsAboutToBeMoved));;
}
void QAbstractItemModel_DisconnectColumnsAboutToBeMoved(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsAboutToBeMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_ColumnsAboutToBeMoved));;
}
void QAbstractItemModel_ConnectColumnsAboutToBeRemoved(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsAboutToBeRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsAboutToBeRemoved));;
}
void QAbstractItemModel_DisconnectColumnsAboutToBeRemoved(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsAboutToBeRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsAboutToBeRemoved));;
}
void QAbstractItemModel_ConnectColumnsInserted(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsInserted));;
}
void QAbstractItemModel_DisconnectColumnsInserted(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsInserted));;
}
void QAbstractItemModel_ConnectColumnsMoved(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_ColumnsMoved));;
}
void QAbstractItemModel_DisconnectColumnsMoved(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_ColumnsMoved));;
}
void QAbstractItemModel_ConnectColumnsRemoved(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsRemoved));;
}
void QAbstractItemModel_DisconnectColumnsRemoved(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsRemoved));;
}
char* QAbstractItemModel_Data(QtObjectPtr ptr, QtObjectPtr index, int role){
return static_cast<QAbstractItemModel*>(ptr)->data(*static_cast<QModelIndex*>(index), role).toString().toUtf8().data();
}
int QAbstractItemModel_DropMimeData(QtObjectPtr ptr, QtObjectPtr data, int action, int row, int column, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
void QAbstractItemModel_FetchMore(QtObjectPtr ptr, QtObjectPtr parent){
static_cast<QAbstractItemModel*>(ptr)->fetchMore(*static_cast<QModelIndex*>(parent));
}
int QAbstractItemModel_Flags(QtObjectPtr ptr, QtObjectPtr index){
return static_cast<QAbstractItemModel*>(ptr)->flags(*static_cast<QModelIndex*>(index));
}
int QAbstractItemModel_HasChildren(QtObjectPtr ptr, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->hasChildren(*static_cast<QModelIndex*>(parent));
}
int QAbstractItemModel_HasIndex(QtObjectPtr ptr, int row, int column, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->hasIndex(row, column, *static_cast<QModelIndex*>(parent));
}
char* QAbstractItemModel_HeaderData(QtObjectPtr ptr, int section, int orientation, int role){
return static_cast<QAbstractItemModel*>(ptr)->headerData(section, static_cast<Qt::Orientation>(orientation), role).toString().toUtf8().data();
}
void QAbstractItemModel_ConnectHeaderDataChanged(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), static_cast<void (QAbstractItemModel::*)(Qt::Orientation, int, int)>(&QAbstractItemModel::headerDataChanged), static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(Qt::Orientation, int, int)>(&MyQAbstractItemModel::Signal_HeaderDataChanged));;
}
void QAbstractItemModel_DisconnectHeaderDataChanged(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), static_cast<void (QAbstractItemModel::*)(Qt::Orientation, int, int)>(&QAbstractItemModel::headerDataChanged), static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(Qt::Orientation, int, int)>(&MyQAbstractItemModel::Signal_HeaderDataChanged));;
}
QtObjectPtr QAbstractItemModel_Index(QtObjectPtr ptr, int row, int column, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)).internalPointer();
}
int QAbstractItemModel_InsertColumn(QtObjectPtr ptr, int column, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->insertColumn(column, *static_cast<QModelIndex*>(parent));
}
int QAbstractItemModel_InsertColumns(QtObjectPtr ptr, int column, int count, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}
int QAbstractItemModel_InsertRow(QtObjectPtr ptr, int row, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->insertRow(row, *static_cast<QModelIndex*>(parent));
}
int QAbstractItemModel_InsertRows(QtObjectPtr ptr, int row, int count, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->insertRows(row, count, *static_cast<QModelIndex*>(parent));
}
char* QAbstractItemModel_MimeTypes(QtObjectPtr ptr){
return static_cast<QAbstractItemModel*>(ptr)->mimeTypes().join("|").toUtf8().data();
}
void QAbstractItemModel_ConnectModelAboutToBeReset(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::modelAboutToBeReset, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)()>(&MyQAbstractItemModel::Signal_ModelAboutToBeReset));;
}
void QAbstractItemModel_DisconnectModelAboutToBeReset(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::modelAboutToBeReset, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)()>(&MyQAbstractItemModel::Signal_ModelAboutToBeReset));;
}
void QAbstractItemModel_ConnectModelReset(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::modelReset, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)()>(&MyQAbstractItemModel::Signal_ModelReset));;
}
void QAbstractItemModel_DisconnectModelReset(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::modelReset, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)()>(&MyQAbstractItemModel::Signal_ModelReset));;
}
int QAbstractItemModel_MoveColumn(QtObjectPtr ptr, QtObjectPtr sourceParent, int sourceColumn, QtObjectPtr destinationParent, int destinationChild){
return static_cast<QAbstractItemModel*>(ptr)->moveColumn(*static_cast<QModelIndex*>(sourceParent), sourceColumn, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
int QAbstractItemModel_MoveColumns(QtObjectPtr ptr, QtObjectPtr sourceParent, int sourceColumn, int count, QtObjectPtr destinationParent, int destinationChild){
return static_cast<QAbstractItemModel*>(ptr)->moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
int QAbstractItemModel_MoveRow(QtObjectPtr ptr, QtObjectPtr sourceParent, int sourceRow, QtObjectPtr destinationParent, int destinationChild){
return static_cast<QAbstractItemModel*>(ptr)->moveRow(*static_cast<QModelIndex*>(sourceParent), sourceRow, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
int QAbstractItemModel_MoveRows(QtObjectPtr ptr, QtObjectPtr sourceParent, int sourceRow, int count, QtObjectPtr destinationParent, int destinationChild){
return static_cast<QAbstractItemModel*>(ptr)->moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
QtObjectPtr QAbstractItemModel_Parent(QtObjectPtr ptr, QtObjectPtr index){
return static_cast<QAbstractItemModel*>(ptr)->parent(*static_cast<QModelIndex*>(index)).internalPointer();
}
int QAbstractItemModel_RemoveColumn(QtObjectPtr ptr, int column, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->removeColumn(column, *static_cast<QModelIndex*>(parent));
}
int QAbstractItemModel_RemoveColumns(QtObjectPtr ptr, int column, int count, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->removeColumns(column, count, *static_cast<QModelIndex*>(parent));
}
int QAbstractItemModel_RemoveRow(QtObjectPtr ptr, int row, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->removeRow(row, *static_cast<QModelIndex*>(parent));
}
int QAbstractItemModel_RemoveRows(QtObjectPtr ptr, int row, int count, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->removeRows(row, count, *static_cast<QModelIndex*>(parent));
}
void QAbstractItemModel_Revert(QtObjectPtr ptr){
QMetaObject::invokeMethod(static_cast<QAbstractItemModel*>(ptr), "revert");
}
int QAbstractItemModel_RowCount(QtObjectPtr ptr, QtObjectPtr parent){
return static_cast<QAbstractItemModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}
void QAbstractItemModel_ConnectRowsAboutToBeInserted(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsAboutToBeInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsAboutToBeInserted));;
}
void QAbstractItemModel_DisconnectRowsAboutToBeInserted(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsAboutToBeInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsAboutToBeInserted));;
}
void QAbstractItemModel_ConnectRowsAboutToBeMoved(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsAboutToBeMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_RowsAboutToBeMoved));;
}
void QAbstractItemModel_DisconnectRowsAboutToBeMoved(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsAboutToBeMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_RowsAboutToBeMoved));;
}
void QAbstractItemModel_ConnectRowsAboutToBeRemoved(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsAboutToBeRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsAboutToBeRemoved));;
}
void QAbstractItemModel_DisconnectRowsAboutToBeRemoved(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsAboutToBeRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsAboutToBeRemoved));;
}
void QAbstractItemModel_ConnectRowsInserted(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsInserted));;
}
void QAbstractItemModel_DisconnectRowsInserted(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsInserted));;
}
void QAbstractItemModel_ConnectRowsMoved(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_RowsMoved));;
}
void QAbstractItemModel_DisconnectRowsMoved(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_RowsMoved));;
}
void QAbstractItemModel_ConnectRowsRemoved(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsRemoved));;
}
void QAbstractItemModel_DisconnectRowsRemoved(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsRemoved));;
}
int QAbstractItemModel_SetData(QtObjectPtr ptr, QtObjectPtr index, char* value, int role){
return static_cast<QAbstractItemModel*>(ptr)->setData(*static_cast<QModelIndex*>(index), QVariant(value), role);
}
int QAbstractItemModel_SetHeaderData(QtObjectPtr ptr, int section, int orientation, char* value, int role){
return static_cast<QAbstractItemModel*>(ptr)->setHeaderData(section, static_cast<Qt::Orientation>(orientation), QVariant(value), role);
}
void QAbstractItemModel_Sort(QtObjectPtr ptr, int column, int order){
static_cast<QAbstractItemModel*>(ptr)->sort(column, static_cast<Qt::SortOrder>(order));
}
int QAbstractItemModel_Submit(QtObjectPtr ptr){
return QMetaObject::invokeMethod(static_cast<QAbstractItemModel*>(ptr), "submit");
}
int QAbstractItemModel_SupportedDragActions(QtObjectPtr ptr){
return static_cast<QAbstractItemModel*>(ptr)->supportedDragActions();
}
int QAbstractItemModel_SupportedDropActions(QtObjectPtr ptr){
return static_cast<QAbstractItemModel*>(ptr)->supportedDropActions();
}
void QAbstractItemModel_DestroyQAbstractItemModel(QtObjectPtr ptr){
static_cast<QAbstractItemModel*>(ptr)->~QAbstractItemModel();
}

581
core/qabstractitemmodel.go Executable file
View file

@ -0,0 +1,581 @@
package core
//#include "qabstractitemmodel.h"
import "C"
import (
"github.com/therecipe/qt"
"strings"
"unsafe"
)
type QAbstractItemModel struct {
QObject
}
type QAbstractItemModelITF interface {
QObjectITF
QAbstractItemModelPTR() *QAbstractItemModel
}
func PointerFromQAbstractItemModel(ptr QAbstractItemModelITF) unsafe.Pointer {
if ptr != nil {
return ptr.QAbstractItemModelPTR().Pointer()
}
return nil
}
func QAbstractItemModelFromPointer(ptr unsafe.Pointer) *QAbstractItemModel {
var n = new(QAbstractItemModel)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QAbstractItemModel_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QAbstractItemModel) QAbstractItemModelPTR() *QAbstractItemModel {
return ptr
}
//QAbstractItemModel::LayoutChangeHint
type QAbstractItemModel__LayoutChangeHint int
var (
QAbstractItemModel__NoLayoutChangeHint = QAbstractItemModel__LayoutChangeHint(0)
QAbstractItemModel__VerticalSortHint = QAbstractItemModel__LayoutChangeHint(1)
QAbstractItemModel__HorizontalSortHint = QAbstractItemModel__LayoutChangeHint(2)
)
func (ptr *QAbstractItemModel) Sibling(row int, column int, index QModelIndexITF) *QModelIndex {
if ptr.Pointer() != nil {
return QModelIndexFromPointer(unsafe.Pointer(C.QAbstractItemModel_Sibling(C.QtObjectPtr(ptr.Pointer()), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(index)))))
}
return nil
}
func (ptr *QAbstractItemModel) Buddy(index QModelIndexITF) *QModelIndex {
if ptr.Pointer() != nil {
return QModelIndexFromPointer(unsafe.Pointer(C.QAbstractItemModel_Buddy(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(index)))))
}
return nil
}
func (ptr *QAbstractItemModel) CanDropMimeData(data QMimeDataITF, action Qt__DropAction, row int, column int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_CanDropMimeData(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQMimeData(data)), C.int(action), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) CanFetchMore(parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_CanFetchMore(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) ColumnCount(parent QModelIndexITF) int {
if ptr.Pointer() != nil {
return int(C.QAbstractItemModel_ColumnCount(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(parent))))
}
return 0
}
func (ptr *QAbstractItemModel) ConnectColumnsAboutToBeInserted(f func(parent QModelIndexITF, first int, last int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectColumnsAboutToBeInserted(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "columnsAboutToBeInserted", f)
}
}
func (ptr *QAbstractItemModel) DisconnectColumnsAboutToBeInserted() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectColumnsAboutToBeInserted(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "columnsAboutToBeInserted")
}
}
//export callbackQAbstractItemModelColumnsAboutToBeInserted
func callbackQAbstractItemModelColumnsAboutToBeInserted(ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
qt.GetSignal(C.GoString(ptrName), "columnsAboutToBeInserted").(func(*QModelIndex, int, int))(QModelIndexFromPointer(parent), int(first), int(last))
}
func (ptr *QAbstractItemModel) ConnectColumnsAboutToBeMoved(f func(sourceParent QModelIndexITF, sourceStart int, sourceEnd int, destinationParent QModelIndexITF, destinationColumn int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectColumnsAboutToBeMoved(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "columnsAboutToBeMoved", f)
}
}
func (ptr *QAbstractItemModel) DisconnectColumnsAboutToBeMoved() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectColumnsAboutToBeMoved(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "columnsAboutToBeMoved")
}
}
//export callbackQAbstractItemModelColumnsAboutToBeMoved
func callbackQAbstractItemModelColumnsAboutToBeMoved(ptrName *C.char, sourceParent unsafe.Pointer, sourceStart C.int, sourceEnd C.int, destinationParent unsafe.Pointer, destinationColumn C.int) {
qt.GetSignal(C.GoString(ptrName), "columnsAboutToBeMoved").(func(*QModelIndex, int, int, *QModelIndex, int))(QModelIndexFromPointer(sourceParent), int(sourceStart), int(sourceEnd), QModelIndexFromPointer(destinationParent), int(destinationColumn))
}
func (ptr *QAbstractItemModel) ConnectColumnsAboutToBeRemoved(f func(parent QModelIndexITF, first int, last int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectColumnsAboutToBeRemoved(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "columnsAboutToBeRemoved", f)
}
}
func (ptr *QAbstractItemModel) DisconnectColumnsAboutToBeRemoved() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectColumnsAboutToBeRemoved(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "columnsAboutToBeRemoved")
}
}
//export callbackQAbstractItemModelColumnsAboutToBeRemoved
func callbackQAbstractItemModelColumnsAboutToBeRemoved(ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
qt.GetSignal(C.GoString(ptrName), "columnsAboutToBeRemoved").(func(*QModelIndex, int, int))(QModelIndexFromPointer(parent), int(first), int(last))
}
func (ptr *QAbstractItemModel) ConnectColumnsInserted(f func(parent QModelIndexITF, first int, last int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectColumnsInserted(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "columnsInserted", f)
}
}
func (ptr *QAbstractItemModel) DisconnectColumnsInserted() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectColumnsInserted(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "columnsInserted")
}
}
//export callbackQAbstractItemModelColumnsInserted
func callbackQAbstractItemModelColumnsInserted(ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
qt.GetSignal(C.GoString(ptrName), "columnsInserted").(func(*QModelIndex, int, int))(QModelIndexFromPointer(parent), int(first), int(last))
}
func (ptr *QAbstractItemModel) ConnectColumnsMoved(f func(parent QModelIndexITF, start int, end int, destination QModelIndexITF, column int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectColumnsMoved(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "columnsMoved", f)
}
}
func (ptr *QAbstractItemModel) DisconnectColumnsMoved() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectColumnsMoved(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "columnsMoved")
}
}
//export callbackQAbstractItemModelColumnsMoved
func callbackQAbstractItemModelColumnsMoved(ptrName *C.char, parent unsafe.Pointer, start C.int, end C.int, destination unsafe.Pointer, column C.int) {
qt.GetSignal(C.GoString(ptrName), "columnsMoved").(func(*QModelIndex, int, int, *QModelIndex, int))(QModelIndexFromPointer(parent), int(start), int(end), QModelIndexFromPointer(destination), int(column))
}
func (ptr *QAbstractItemModel) ConnectColumnsRemoved(f func(parent QModelIndexITF, first int, last int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectColumnsRemoved(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "columnsRemoved", f)
}
}
func (ptr *QAbstractItemModel) DisconnectColumnsRemoved() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectColumnsRemoved(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "columnsRemoved")
}
}
//export callbackQAbstractItemModelColumnsRemoved
func callbackQAbstractItemModelColumnsRemoved(ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
qt.GetSignal(C.GoString(ptrName), "columnsRemoved").(func(*QModelIndex, int, int))(QModelIndexFromPointer(parent), int(first), int(last))
}
func (ptr *QAbstractItemModel) Data(index QModelIndexITF, role int) string {
if ptr.Pointer() != nil {
return C.GoString(C.QAbstractItemModel_Data(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(index)), C.int(role)))
}
return ""
}
func (ptr *QAbstractItemModel) DropMimeData(data QMimeDataITF, action Qt__DropAction, row int, column int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_DropMimeData(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQMimeData(data)), C.int(action), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) FetchMore(parent QModelIndexITF) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_FetchMore(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(parent)))
}
}
func (ptr *QAbstractItemModel) Flags(index QModelIndexITF) Qt__ItemFlag {
if ptr.Pointer() != nil {
return Qt__ItemFlag(C.QAbstractItemModel_Flags(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(index))))
}
return 0
}
func (ptr *QAbstractItemModel) HasChildren(parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_HasChildren(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) HasIndex(row int, column int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_HasIndex(C.QtObjectPtr(ptr.Pointer()), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) HeaderData(section int, orientation Qt__Orientation, role int) string {
if ptr.Pointer() != nil {
return C.GoString(C.QAbstractItemModel_HeaderData(C.QtObjectPtr(ptr.Pointer()), C.int(section), C.int(orientation), C.int(role)))
}
return ""
}
func (ptr *QAbstractItemModel) ConnectHeaderDataChanged(f func(orientation Qt__Orientation, first int, last int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectHeaderDataChanged(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "headerDataChanged", f)
}
}
func (ptr *QAbstractItemModel) DisconnectHeaderDataChanged() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectHeaderDataChanged(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "headerDataChanged")
}
}
//export callbackQAbstractItemModelHeaderDataChanged
func callbackQAbstractItemModelHeaderDataChanged(ptrName *C.char, orientation C.int, first C.int, last C.int) {
qt.GetSignal(C.GoString(ptrName), "headerDataChanged").(func(Qt__Orientation, int, int))(Qt__Orientation(orientation), int(first), int(last))
}
func (ptr *QAbstractItemModel) Index(row int, column int, parent QModelIndexITF) *QModelIndex {
if ptr.Pointer() != nil {
return QModelIndexFromPointer(unsafe.Pointer(C.QAbstractItemModel_Index(C.QtObjectPtr(ptr.Pointer()), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(parent)))))
}
return nil
}
func (ptr *QAbstractItemModel) InsertColumn(column int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_InsertColumn(C.QtObjectPtr(ptr.Pointer()), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) InsertColumns(column int, count int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_InsertColumns(C.QtObjectPtr(ptr.Pointer()), C.int(column), C.int(count), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) InsertRow(row int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_InsertRow(C.QtObjectPtr(ptr.Pointer()), C.int(row), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) InsertRows(row int, count int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_InsertRows(C.QtObjectPtr(ptr.Pointer()), C.int(row), C.int(count), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) MimeTypes() []string {
if ptr.Pointer() != nil {
return strings.Split(C.GoString(C.QAbstractItemModel_MimeTypes(C.QtObjectPtr(ptr.Pointer()))), "|")
}
return make([]string, 0)
}
func (ptr *QAbstractItemModel) ConnectModelAboutToBeReset(f func()) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectModelAboutToBeReset(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "modelAboutToBeReset", f)
}
}
func (ptr *QAbstractItemModel) DisconnectModelAboutToBeReset() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectModelAboutToBeReset(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "modelAboutToBeReset")
}
}
//export callbackQAbstractItemModelModelAboutToBeReset
func callbackQAbstractItemModelModelAboutToBeReset(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "modelAboutToBeReset").(func())()
}
func (ptr *QAbstractItemModel) ConnectModelReset(f func()) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectModelReset(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "modelReset", f)
}
}
func (ptr *QAbstractItemModel) DisconnectModelReset() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectModelReset(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "modelReset")
}
}
//export callbackQAbstractItemModelModelReset
func callbackQAbstractItemModelModelReset(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "modelReset").(func())()
}
func (ptr *QAbstractItemModel) MoveColumn(sourceParent QModelIndexITF, sourceColumn int, destinationParent QModelIndexITF, destinationChild int) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_MoveColumn(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(sourceParent)), C.int(sourceColumn), C.QtObjectPtr(PointerFromQModelIndex(destinationParent)), C.int(destinationChild)) != 0
}
return false
}
func (ptr *QAbstractItemModel) MoveColumns(sourceParent QModelIndexITF, sourceColumn int, count int, destinationParent QModelIndexITF, destinationChild int) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_MoveColumns(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(sourceParent)), C.int(sourceColumn), C.int(count), C.QtObjectPtr(PointerFromQModelIndex(destinationParent)), C.int(destinationChild)) != 0
}
return false
}
func (ptr *QAbstractItemModel) MoveRow(sourceParent QModelIndexITF, sourceRow int, destinationParent QModelIndexITF, destinationChild int) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_MoveRow(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(sourceParent)), C.int(sourceRow), C.QtObjectPtr(PointerFromQModelIndex(destinationParent)), C.int(destinationChild)) != 0
}
return false
}
func (ptr *QAbstractItemModel) MoveRows(sourceParent QModelIndexITF, sourceRow int, count int, destinationParent QModelIndexITF, destinationChild int) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_MoveRows(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(sourceParent)), C.int(sourceRow), C.int(count), C.QtObjectPtr(PointerFromQModelIndex(destinationParent)), C.int(destinationChild)) != 0
}
return false
}
func (ptr *QAbstractItemModel) Parent(index QModelIndexITF) *QModelIndex {
if ptr.Pointer() != nil {
return QModelIndexFromPointer(unsafe.Pointer(C.QAbstractItemModel_Parent(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(index)))))
}
return nil
}
func (ptr *QAbstractItemModel) RemoveColumn(column int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_RemoveColumn(C.QtObjectPtr(ptr.Pointer()), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) RemoveColumns(column int, count int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_RemoveColumns(C.QtObjectPtr(ptr.Pointer()), C.int(column), C.int(count), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) RemoveRow(row int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_RemoveRow(C.QtObjectPtr(ptr.Pointer()), C.int(row), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) RemoveRows(row int, count int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_RemoveRows(C.QtObjectPtr(ptr.Pointer()), C.int(row), C.int(count), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractItemModel) Revert() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_Revert(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QAbstractItemModel) RowCount(parent QModelIndexITF) int {
if ptr.Pointer() != nil {
return int(C.QAbstractItemModel_RowCount(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(parent))))
}
return 0
}
func (ptr *QAbstractItemModel) ConnectRowsAboutToBeInserted(f func(parent QModelIndexITF, start int, end int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectRowsAboutToBeInserted(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "rowsAboutToBeInserted", f)
}
}
func (ptr *QAbstractItemModel) DisconnectRowsAboutToBeInserted() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectRowsAboutToBeInserted(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "rowsAboutToBeInserted")
}
}
//export callbackQAbstractItemModelRowsAboutToBeInserted
func callbackQAbstractItemModelRowsAboutToBeInserted(ptrName *C.char, parent unsafe.Pointer, start C.int, end C.int) {
qt.GetSignal(C.GoString(ptrName), "rowsAboutToBeInserted").(func(*QModelIndex, int, int))(QModelIndexFromPointer(parent), int(start), int(end))
}
func (ptr *QAbstractItemModel) ConnectRowsAboutToBeMoved(f func(sourceParent QModelIndexITF, sourceStart int, sourceEnd int, destinationParent QModelIndexITF, destinationRow int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectRowsAboutToBeMoved(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "rowsAboutToBeMoved", f)
}
}
func (ptr *QAbstractItemModel) DisconnectRowsAboutToBeMoved() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectRowsAboutToBeMoved(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "rowsAboutToBeMoved")
}
}
//export callbackQAbstractItemModelRowsAboutToBeMoved
func callbackQAbstractItemModelRowsAboutToBeMoved(ptrName *C.char, sourceParent unsafe.Pointer, sourceStart C.int, sourceEnd C.int, destinationParent unsafe.Pointer, destinationRow C.int) {
qt.GetSignal(C.GoString(ptrName), "rowsAboutToBeMoved").(func(*QModelIndex, int, int, *QModelIndex, int))(QModelIndexFromPointer(sourceParent), int(sourceStart), int(sourceEnd), QModelIndexFromPointer(destinationParent), int(destinationRow))
}
func (ptr *QAbstractItemModel) ConnectRowsAboutToBeRemoved(f func(parent QModelIndexITF, first int, last int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectRowsAboutToBeRemoved(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "rowsAboutToBeRemoved", f)
}
}
func (ptr *QAbstractItemModel) DisconnectRowsAboutToBeRemoved() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectRowsAboutToBeRemoved(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "rowsAboutToBeRemoved")
}
}
//export callbackQAbstractItemModelRowsAboutToBeRemoved
func callbackQAbstractItemModelRowsAboutToBeRemoved(ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
qt.GetSignal(C.GoString(ptrName), "rowsAboutToBeRemoved").(func(*QModelIndex, int, int))(QModelIndexFromPointer(parent), int(first), int(last))
}
func (ptr *QAbstractItemModel) ConnectRowsInserted(f func(parent QModelIndexITF, first int, last int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectRowsInserted(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "rowsInserted", f)
}
}
func (ptr *QAbstractItemModel) DisconnectRowsInserted() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectRowsInserted(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "rowsInserted")
}
}
//export callbackQAbstractItemModelRowsInserted
func callbackQAbstractItemModelRowsInserted(ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
qt.GetSignal(C.GoString(ptrName), "rowsInserted").(func(*QModelIndex, int, int))(QModelIndexFromPointer(parent), int(first), int(last))
}
func (ptr *QAbstractItemModel) ConnectRowsMoved(f func(parent QModelIndexITF, start int, end int, destination QModelIndexITF, row int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectRowsMoved(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "rowsMoved", f)
}
}
func (ptr *QAbstractItemModel) DisconnectRowsMoved() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectRowsMoved(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "rowsMoved")
}
}
//export callbackQAbstractItemModelRowsMoved
func callbackQAbstractItemModelRowsMoved(ptrName *C.char, parent unsafe.Pointer, start C.int, end C.int, destination unsafe.Pointer, row C.int) {
qt.GetSignal(C.GoString(ptrName), "rowsMoved").(func(*QModelIndex, int, int, *QModelIndex, int))(QModelIndexFromPointer(parent), int(start), int(end), QModelIndexFromPointer(destination), int(row))
}
func (ptr *QAbstractItemModel) ConnectRowsRemoved(f func(parent QModelIndexITF, first int, last int)) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_ConnectRowsRemoved(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "rowsRemoved", f)
}
}
func (ptr *QAbstractItemModel) DisconnectRowsRemoved() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DisconnectRowsRemoved(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "rowsRemoved")
}
}
//export callbackQAbstractItemModelRowsRemoved
func callbackQAbstractItemModelRowsRemoved(ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
qt.GetSignal(C.GoString(ptrName), "rowsRemoved").(func(*QModelIndex, int, int))(QModelIndexFromPointer(parent), int(first), int(last))
}
func (ptr *QAbstractItemModel) SetData(index QModelIndexITF, value string, role int) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_SetData(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(index)), C.CString(value), C.int(role)) != 0
}
return false
}
func (ptr *QAbstractItemModel) SetHeaderData(section int, orientation Qt__Orientation, value string, role int) bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_SetHeaderData(C.QtObjectPtr(ptr.Pointer()), C.int(section), C.int(orientation), C.CString(value), C.int(role)) != 0
}
return false
}
func (ptr *QAbstractItemModel) Sort(column int, order Qt__SortOrder) {
if ptr.Pointer() != nil {
C.QAbstractItemModel_Sort(C.QtObjectPtr(ptr.Pointer()), C.int(column), C.int(order))
}
}
func (ptr *QAbstractItemModel) Submit() bool {
if ptr.Pointer() != nil {
return C.QAbstractItemModel_Submit(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QAbstractItemModel) SupportedDragActions() Qt__DropAction {
if ptr.Pointer() != nil {
return Qt__DropAction(C.QAbstractItemModel_SupportedDragActions(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAbstractItemModel) SupportedDropActions() Qt__DropAction {
if ptr.Pointer() != nil {
return Qt__DropAction(C.QAbstractItemModel_SupportedDropActions(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAbstractItemModel) DestroyQAbstractItemModel() {
if ptr.Pointer() != nil {
C.QAbstractItemModel_DestroyQAbstractItemModel(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

75
core/qabstractitemmodel.h Executable file
View file

@ -0,0 +1,75 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QAbstractItemModel_Sibling(QtObjectPtr ptr, int row, int column, QtObjectPtr index);
QtObjectPtr QAbstractItemModel_Buddy(QtObjectPtr ptr, QtObjectPtr index);
int QAbstractItemModel_CanDropMimeData(QtObjectPtr ptr, QtObjectPtr data, int action, int row, int column, QtObjectPtr parent);
int QAbstractItemModel_CanFetchMore(QtObjectPtr ptr, QtObjectPtr parent);
int QAbstractItemModel_ColumnCount(QtObjectPtr ptr, QtObjectPtr parent);
void QAbstractItemModel_ConnectColumnsAboutToBeInserted(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectColumnsAboutToBeInserted(QtObjectPtr ptr);
void QAbstractItemModel_ConnectColumnsAboutToBeMoved(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectColumnsAboutToBeMoved(QtObjectPtr ptr);
void QAbstractItemModel_ConnectColumnsAboutToBeRemoved(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectColumnsAboutToBeRemoved(QtObjectPtr ptr);
void QAbstractItemModel_ConnectColumnsInserted(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectColumnsInserted(QtObjectPtr ptr);
void QAbstractItemModel_ConnectColumnsMoved(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectColumnsMoved(QtObjectPtr ptr);
void QAbstractItemModel_ConnectColumnsRemoved(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectColumnsRemoved(QtObjectPtr ptr);
char* QAbstractItemModel_Data(QtObjectPtr ptr, QtObjectPtr index, int role);
int QAbstractItemModel_DropMimeData(QtObjectPtr ptr, QtObjectPtr data, int action, int row, int column, QtObjectPtr parent);
void QAbstractItemModel_FetchMore(QtObjectPtr ptr, QtObjectPtr parent);
int QAbstractItemModel_Flags(QtObjectPtr ptr, QtObjectPtr index);
int QAbstractItemModel_HasChildren(QtObjectPtr ptr, QtObjectPtr parent);
int QAbstractItemModel_HasIndex(QtObjectPtr ptr, int row, int column, QtObjectPtr parent);
char* QAbstractItemModel_HeaderData(QtObjectPtr ptr, int section, int orientation, int role);
void QAbstractItemModel_ConnectHeaderDataChanged(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectHeaderDataChanged(QtObjectPtr ptr);
QtObjectPtr QAbstractItemModel_Index(QtObjectPtr ptr, int row, int column, QtObjectPtr parent);
int QAbstractItemModel_InsertColumn(QtObjectPtr ptr, int column, QtObjectPtr parent);
int QAbstractItemModel_InsertColumns(QtObjectPtr ptr, int column, int count, QtObjectPtr parent);
int QAbstractItemModel_InsertRow(QtObjectPtr ptr, int row, QtObjectPtr parent);
int QAbstractItemModel_InsertRows(QtObjectPtr ptr, int row, int count, QtObjectPtr parent);
char* QAbstractItemModel_MimeTypes(QtObjectPtr ptr);
void QAbstractItemModel_ConnectModelAboutToBeReset(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectModelAboutToBeReset(QtObjectPtr ptr);
void QAbstractItemModel_ConnectModelReset(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectModelReset(QtObjectPtr ptr);
int QAbstractItemModel_MoveColumn(QtObjectPtr ptr, QtObjectPtr sourceParent, int sourceColumn, QtObjectPtr destinationParent, int destinationChild);
int QAbstractItemModel_MoveColumns(QtObjectPtr ptr, QtObjectPtr sourceParent, int sourceColumn, int count, QtObjectPtr destinationParent, int destinationChild);
int QAbstractItemModel_MoveRow(QtObjectPtr ptr, QtObjectPtr sourceParent, int sourceRow, QtObjectPtr destinationParent, int destinationChild);
int QAbstractItemModel_MoveRows(QtObjectPtr ptr, QtObjectPtr sourceParent, int sourceRow, int count, QtObjectPtr destinationParent, int destinationChild);
QtObjectPtr QAbstractItemModel_Parent(QtObjectPtr ptr, QtObjectPtr index);
int QAbstractItemModel_RemoveColumn(QtObjectPtr ptr, int column, QtObjectPtr parent);
int QAbstractItemModel_RemoveColumns(QtObjectPtr ptr, int column, int count, QtObjectPtr parent);
int QAbstractItemModel_RemoveRow(QtObjectPtr ptr, int row, QtObjectPtr parent);
int QAbstractItemModel_RemoveRows(QtObjectPtr ptr, int row, int count, QtObjectPtr parent);
void QAbstractItemModel_Revert(QtObjectPtr ptr);
int QAbstractItemModel_RowCount(QtObjectPtr ptr, QtObjectPtr parent);
void QAbstractItemModel_ConnectRowsAboutToBeInserted(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectRowsAboutToBeInserted(QtObjectPtr ptr);
void QAbstractItemModel_ConnectRowsAboutToBeMoved(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectRowsAboutToBeMoved(QtObjectPtr ptr);
void QAbstractItemModel_ConnectRowsAboutToBeRemoved(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectRowsAboutToBeRemoved(QtObjectPtr ptr);
void QAbstractItemModel_ConnectRowsInserted(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectRowsInserted(QtObjectPtr ptr);
void QAbstractItemModel_ConnectRowsMoved(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectRowsMoved(QtObjectPtr ptr);
void QAbstractItemModel_ConnectRowsRemoved(QtObjectPtr ptr);
void QAbstractItemModel_DisconnectRowsRemoved(QtObjectPtr ptr);
int QAbstractItemModel_SetData(QtObjectPtr ptr, QtObjectPtr index, char* value, int role);
int QAbstractItemModel_SetHeaderData(QtObjectPtr ptr, int section, int orientation, char* value, int role);
void QAbstractItemModel_Sort(QtObjectPtr ptr, int column, int order);
int QAbstractItemModel_Submit(QtObjectPtr ptr);
int QAbstractItemModel_SupportedDragActions(QtObjectPtr ptr);
int QAbstractItemModel_SupportedDropActions(QtObjectPtr ptr);
void QAbstractItemModel_DestroyQAbstractItemModel(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

35
core/qabstractlistmodel.cpp Executable file
View file

@ -0,0 +1,35 @@
#include "qabstractlistmodel.h"
#include <QList>
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QList>
#include <QMimeData>
#include <QAbstractListModel>
#include "_cgo_export.h"
class MyQAbstractListModel: public QAbstractListModel {
public:
};
QtObjectPtr QAbstractListModel_Index(QtObjectPtr ptr, int row, int column, QtObjectPtr parent){
return static_cast<QAbstractListModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)).internalPointer();
}
int QAbstractListModel_DropMimeData(QtObjectPtr ptr, QtObjectPtr data, int action, int row, int column, QtObjectPtr parent){
return static_cast<QAbstractListModel*>(ptr)->dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
int QAbstractListModel_Flags(QtObjectPtr ptr, QtObjectPtr index){
return static_cast<QAbstractListModel*>(ptr)->flags(*static_cast<QModelIndex*>(index));
}
QtObjectPtr QAbstractListModel_Sibling(QtObjectPtr ptr, int row, int column, QtObjectPtr idx){
return static_cast<QAbstractListModel*>(ptr)->sibling(row, column, *static_cast<QModelIndex*>(idx)).internalPointer();
}
void QAbstractListModel_DestroyQAbstractListModel(QtObjectPtr ptr){
static_cast<QAbstractListModel*>(ptr)->~QAbstractListModel();
}

72
core/qabstractlistmodel.go Executable file
View file

@ -0,0 +1,72 @@
package core
//#include "qabstractlistmodel.h"
import "C"
import (
"github.com/therecipe/qt"
"unsafe"
)
type QAbstractListModel struct {
QAbstractItemModel
}
type QAbstractListModelITF interface {
QAbstractItemModelITF
QAbstractListModelPTR() *QAbstractListModel
}
func PointerFromQAbstractListModel(ptr QAbstractListModelITF) unsafe.Pointer {
if ptr != nil {
return ptr.QAbstractListModelPTR().Pointer()
}
return nil
}
func QAbstractListModelFromPointer(ptr unsafe.Pointer) *QAbstractListModel {
var n = new(QAbstractListModel)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QAbstractListModel_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QAbstractListModel) QAbstractListModelPTR() *QAbstractListModel {
return ptr
}
func (ptr *QAbstractListModel) Index(row int, column int, parent QModelIndexITF) *QModelIndex {
if ptr.Pointer() != nil {
return QModelIndexFromPointer(unsafe.Pointer(C.QAbstractListModel_Index(C.QtObjectPtr(ptr.Pointer()), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(parent)))))
}
return nil
}
func (ptr *QAbstractListModel) DropMimeData(data QMimeDataITF, action Qt__DropAction, row int, column int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractListModel_DropMimeData(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQMimeData(data)), C.int(action), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractListModel) Flags(index QModelIndexITF) Qt__ItemFlag {
if ptr.Pointer() != nil {
return Qt__ItemFlag(C.QAbstractListModel_Flags(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(index))))
}
return 0
}
func (ptr *QAbstractListModel) Sibling(row int, column int, idx QModelIndexITF) *QModelIndex {
if ptr.Pointer() != nil {
return QModelIndexFromPointer(unsafe.Pointer(C.QAbstractListModel_Sibling(C.QtObjectPtr(ptr.Pointer()), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(idx)))))
}
return nil
}
func (ptr *QAbstractListModel) DestroyQAbstractListModel() {
if ptr.Pointer() != nil {
C.QAbstractListModel_DestroyQAbstractListModel(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

14
core/qabstractlistmodel.h Executable file
View file

@ -0,0 +1,14 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QAbstractListModel_Index(QtObjectPtr ptr, int row, int column, QtObjectPtr parent);
int QAbstractListModel_DropMimeData(QtObjectPtr ptr, QtObjectPtr data, int action, int row, int column, QtObjectPtr parent);
int QAbstractListModel_Flags(QtObjectPtr ptr, QtObjectPtr index);
QtObjectPtr QAbstractListModel_Sibling(QtObjectPtr ptr, int row, int column, QtObjectPtr idx);
void QAbstractListModel_DestroyQAbstractListModel(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

16
core/qabstractnativeeventfilter.cpp Executable file
View file

@ -0,0 +1,16 @@
#include "qabstractnativeeventfilter.h"
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QAbstractNativeEventFilter>
#include "_cgo_export.h"
class MyQAbstractNativeEventFilter: public QAbstractNativeEventFilter {
public:
};
void QAbstractNativeEventFilter_DestroyQAbstractNativeEventFilter(QtObjectPtr ptr){
static_cast<QAbstractNativeEventFilter*>(ptr)->~QAbstractNativeEventFilter();
}

46
core/qabstractnativeeventfilter.go Executable file
View file

@ -0,0 +1,46 @@
package core
//#include "qabstractnativeeventfilter.h"
import "C"
import (
"unsafe"
)
type QAbstractNativeEventFilter struct {
ptr unsafe.Pointer
}
type QAbstractNativeEventFilterITF interface {
QAbstractNativeEventFilterPTR() *QAbstractNativeEventFilter
}
func (p *QAbstractNativeEventFilter) Pointer() unsafe.Pointer {
return p.ptr
}
func (p *QAbstractNativeEventFilter) SetPointer(ptr unsafe.Pointer) {
p.ptr = ptr
}
func PointerFromQAbstractNativeEventFilter(ptr QAbstractNativeEventFilterITF) unsafe.Pointer {
if ptr != nil {
return ptr.QAbstractNativeEventFilterPTR().Pointer()
}
return nil
}
func QAbstractNativeEventFilterFromPointer(ptr unsafe.Pointer) *QAbstractNativeEventFilter {
var n = new(QAbstractNativeEventFilter)
n.SetPointer(ptr)
return n
}
func (ptr *QAbstractNativeEventFilter) QAbstractNativeEventFilterPTR() *QAbstractNativeEventFilter {
return ptr
}
func (ptr *QAbstractNativeEventFilter) DestroyQAbstractNativeEventFilter() {
if ptr.Pointer() != nil {
C.QAbstractNativeEventFilter_DestroyQAbstractNativeEventFilter(C.QtObjectPtr(ptr.Pointer()))
}
}

10
core/qabstractnativeeventfilter.h Executable file
View file

@ -0,0 +1,10 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
void QAbstractNativeEventFilter_DestroyQAbstractNativeEventFilter(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

116
core/qabstractproxymodel.cpp Executable file
View file

@ -0,0 +1,116 @@
#include "qabstractproxymodel.h"
#include <QObject>
#include <QMimeData>
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QAbstractItemModel>
#include <QAbstractProxyModel>
#include "_cgo_export.h"
class MyQAbstractProxyModel: public QAbstractProxyModel {
public:
void Signal_SourceModelChanged(){callbackQAbstractProxyModelSourceModelChanged(this->objectName().toUtf8().data());};
};
QtObjectPtr QAbstractProxyModel_Buddy(QtObjectPtr ptr, QtObjectPtr index){
return static_cast<QAbstractProxyModel*>(ptr)->buddy(*static_cast<QModelIndex*>(index)).internalPointer();
}
int QAbstractProxyModel_CanDropMimeData(QtObjectPtr ptr, QtObjectPtr data, int action, int row, int column, QtObjectPtr parent){
return static_cast<QAbstractProxyModel*>(ptr)->canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
int QAbstractProxyModel_CanFetchMore(QtObjectPtr ptr, QtObjectPtr parent){
return static_cast<QAbstractProxyModel*>(ptr)->canFetchMore(*static_cast<QModelIndex*>(parent));
}
char* QAbstractProxyModel_Data(QtObjectPtr ptr, QtObjectPtr proxyIndex, int role){
return static_cast<QAbstractProxyModel*>(ptr)->data(*static_cast<QModelIndex*>(proxyIndex), role).toString().toUtf8().data();
}
int QAbstractProxyModel_DropMimeData(QtObjectPtr ptr, QtObjectPtr data, int action, int row, int column, QtObjectPtr parent){
return static_cast<QAbstractProxyModel*>(ptr)->dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
void QAbstractProxyModel_FetchMore(QtObjectPtr ptr, QtObjectPtr parent){
static_cast<QAbstractProxyModel*>(ptr)->fetchMore(*static_cast<QModelIndex*>(parent));
}
int QAbstractProxyModel_Flags(QtObjectPtr ptr, QtObjectPtr index){
return static_cast<QAbstractProxyModel*>(ptr)->flags(*static_cast<QModelIndex*>(index));
}
int QAbstractProxyModel_HasChildren(QtObjectPtr ptr, QtObjectPtr parent){
return static_cast<QAbstractProxyModel*>(ptr)->hasChildren(*static_cast<QModelIndex*>(parent));
}
char* QAbstractProxyModel_HeaderData(QtObjectPtr ptr, int section, int orientation, int role){
return static_cast<QAbstractProxyModel*>(ptr)->headerData(section, static_cast<Qt::Orientation>(orientation), role).toString().toUtf8().data();
}
QtObjectPtr QAbstractProxyModel_MapFromSource(QtObjectPtr ptr, QtObjectPtr sourceIndex){
return static_cast<QAbstractProxyModel*>(ptr)->mapFromSource(*static_cast<QModelIndex*>(sourceIndex)).internalPointer();
}
QtObjectPtr QAbstractProxyModel_MapToSource(QtObjectPtr ptr, QtObjectPtr proxyIndex){
return static_cast<QAbstractProxyModel*>(ptr)->mapToSource(*static_cast<QModelIndex*>(proxyIndex)).internalPointer();
}
char* QAbstractProxyModel_MimeTypes(QtObjectPtr ptr){
return static_cast<QAbstractProxyModel*>(ptr)->mimeTypes().join("|").toUtf8().data();
}
void QAbstractProxyModel_Revert(QtObjectPtr ptr){
static_cast<QAbstractProxyModel*>(ptr)->revert();
}
int QAbstractProxyModel_SetData(QtObjectPtr ptr, QtObjectPtr index, char* value, int role){
return static_cast<QAbstractProxyModel*>(ptr)->setData(*static_cast<QModelIndex*>(index), QVariant(value), role);
}
int QAbstractProxyModel_SetHeaderData(QtObjectPtr ptr, int section, int orientation, char* value, int role){
return static_cast<QAbstractProxyModel*>(ptr)->setHeaderData(section, static_cast<Qt::Orientation>(orientation), QVariant(value), role);
}
void QAbstractProxyModel_SetSourceModel(QtObjectPtr ptr, QtObjectPtr sourceModel){
static_cast<QAbstractProxyModel*>(ptr)->setSourceModel(static_cast<QAbstractItemModel*>(sourceModel));
}
QtObjectPtr QAbstractProxyModel_Sibling(QtObjectPtr ptr, int row, int column, QtObjectPtr idx){
return static_cast<QAbstractProxyModel*>(ptr)->sibling(row, column, *static_cast<QModelIndex*>(idx)).internalPointer();
}
void QAbstractProxyModel_Sort(QtObjectPtr ptr, int column, int order){
static_cast<QAbstractProxyModel*>(ptr)->sort(column, static_cast<Qt::SortOrder>(order));
}
QtObjectPtr QAbstractProxyModel_SourceModel(QtObjectPtr ptr){
return static_cast<QAbstractProxyModel*>(ptr)->sourceModel();
}
void QAbstractProxyModel_ConnectSourceModelChanged(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractProxyModel*>(ptr), &QAbstractProxyModel::sourceModelChanged, static_cast<MyQAbstractProxyModel*>(ptr), static_cast<void (MyQAbstractProxyModel::*)()>(&MyQAbstractProxyModel::Signal_SourceModelChanged));;
}
void QAbstractProxyModel_DisconnectSourceModelChanged(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractProxyModel*>(ptr), &QAbstractProxyModel::sourceModelChanged, static_cast<MyQAbstractProxyModel*>(ptr), static_cast<void (MyQAbstractProxyModel::*)()>(&MyQAbstractProxyModel::Signal_SourceModelChanged));;
}
int QAbstractProxyModel_Submit(QtObjectPtr ptr){
return static_cast<QAbstractProxyModel*>(ptr)->submit();
}
int QAbstractProxyModel_SupportedDragActions(QtObjectPtr ptr){
return static_cast<QAbstractProxyModel*>(ptr)->supportedDragActions();
}
int QAbstractProxyModel_SupportedDropActions(QtObjectPtr ptr){
return static_cast<QAbstractProxyModel*>(ptr)->supportedDropActions();
}
void QAbstractProxyModel_DestroyQAbstractProxyModel(QtObjectPtr ptr){
static_cast<QAbstractProxyModel*>(ptr)->~QAbstractProxyModel();
}

214
core/qabstractproxymodel.go Executable file
View file

@ -0,0 +1,214 @@
package core
//#include "qabstractproxymodel.h"
import "C"
import (
"github.com/therecipe/qt"
"strings"
"unsafe"
)
type QAbstractProxyModel struct {
QAbstractItemModel
}
type QAbstractProxyModelITF interface {
QAbstractItemModelITF
QAbstractProxyModelPTR() *QAbstractProxyModel
}
func PointerFromQAbstractProxyModel(ptr QAbstractProxyModelITF) unsafe.Pointer {
if ptr != nil {
return ptr.QAbstractProxyModelPTR().Pointer()
}
return nil
}
func QAbstractProxyModelFromPointer(ptr unsafe.Pointer) *QAbstractProxyModel {
var n = new(QAbstractProxyModel)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QAbstractProxyModel_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QAbstractProxyModel) QAbstractProxyModelPTR() *QAbstractProxyModel {
return ptr
}
func (ptr *QAbstractProxyModel) Buddy(index QModelIndexITF) *QModelIndex {
if ptr.Pointer() != nil {
return QModelIndexFromPointer(unsafe.Pointer(C.QAbstractProxyModel_Buddy(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(index)))))
}
return nil
}
func (ptr *QAbstractProxyModel) CanDropMimeData(data QMimeDataITF, action Qt__DropAction, row int, column int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractProxyModel_CanDropMimeData(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQMimeData(data)), C.int(action), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractProxyModel) CanFetchMore(parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractProxyModel_CanFetchMore(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractProxyModel) Data(proxyIndex QModelIndexITF, role int) string {
if ptr.Pointer() != nil {
return C.GoString(C.QAbstractProxyModel_Data(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(proxyIndex)), C.int(role)))
}
return ""
}
func (ptr *QAbstractProxyModel) DropMimeData(data QMimeDataITF, action Qt__DropAction, row int, column int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractProxyModel_DropMimeData(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQMimeData(data)), C.int(action), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractProxyModel) FetchMore(parent QModelIndexITF) {
if ptr.Pointer() != nil {
C.QAbstractProxyModel_FetchMore(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(parent)))
}
}
func (ptr *QAbstractProxyModel) Flags(index QModelIndexITF) Qt__ItemFlag {
if ptr.Pointer() != nil {
return Qt__ItemFlag(C.QAbstractProxyModel_Flags(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(index))))
}
return 0
}
func (ptr *QAbstractProxyModel) HasChildren(parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractProxyModel_HasChildren(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractProxyModel) HeaderData(section int, orientation Qt__Orientation, role int) string {
if ptr.Pointer() != nil {
return C.GoString(C.QAbstractProxyModel_HeaderData(C.QtObjectPtr(ptr.Pointer()), C.int(section), C.int(orientation), C.int(role)))
}
return ""
}
func (ptr *QAbstractProxyModel) MapFromSource(sourceIndex QModelIndexITF) *QModelIndex {
if ptr.Pointer() != nil {
return QModelIndexFromPointer(unsafe.Pointer(C.QAbstractProxyModel_MapFromSource(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(sourceIndex)))))
}
return nil
}
func (ptr *QAbstractProxyModel) MapToSource(proxyIndex QModelIndexITF) *QModelIndex {
if ptr.Pointer() != nil {
return QModelIndexFromPointer(unsafe.Pointer(C.QAbstractProxyModel_MapToSource(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(proxyIndex)))))
}
return nil
}
func (ptr *QAbstractProxyModel) MimeTypes() []string {
if ptr.Pointer() != nil {
return strings.Split(C.GoString(C.QAbstractProxyModel_MimeTypes(C.QtObjectPtr(ptr.Pointer()))), "|")
}
return make([]string, 0)
}
func (ptr *QAbstractProxyModel) Revert() {
if ptr.Pointer() != nil {
C.QAbstractProxyModel_Revert(C.QtObjectPtr(ptr.Pointer()))
}
}
func (ptr *QAbstractProxyModel) SetData(index QModelIndexITF, value string, role int) bool {
if ptr.Pointer() != nil {
return C.QAbstractProxyModel_SetData(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(index)), C.CString(value), C.int(role)) != 0
}
return false
}
func (ptr *QAbstractProxyModel) SetHeaderData(section int, orientation Qt__Orientation, value string, role int) bool {
if ptr.Pointer() != nil {
return C.QAbstractProxyModel_SetHeaderData(C.QtObjectPtr(ptr.Pointer()), C.int(section), C.int(orientation), C.CString(value), C.int(role)) != 0
}
return false
}
func (ptr *QAbstractProxyModel) SetSourceModel(sourceModel QAbstractItemModelITF) {
if ptr.Pointer() != nil {
C.QAbstractProxyModel_SetSourceModel(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQAbstractItemModel(sourceModel)))
}
}
func (ptr *QAbstractProxyModel) Sibling(row int, column int, idx QModelIndexITF) *QModelIndex {
if ptr.Pointer() != nil {
return QModelIndexFromPointer(unsafe.Pointer(C.QAbstractProxyModel_Sibling(C.QtObjectPtr(ptr.Pointer()), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(idx)))))
}
return nil
}
func (ptr *QAbstractProxyModel) Sort(column int, order Qt__SortOrder) {
if ptr.Pointer() != nil {
C.QAbstractProxyModel_Sort(C.QtObjectPtr(ptr.Pointer()), C.int(column), C.int(order))
}
}
func (ptr *QAbstractProxyModel) SourceModel() *QAbstractItemModel {
if ptr.Pointer() != nil {
return QAbstractItemModelFromPointer(unsafe.Pointer(C.QAbstractProxyModel_SourceModel(C.QtObjectPtr(ptr.Pointer()))))
}
return nil
}
func (ptr *QAbstractProxyModel) ConnectSourceModelChanged(f func()) {
if ptr.Pointer() != nil {
C.QAbstractProxyModel_ConnectSourceModelChanged(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "sourceModelChanged", f)
}
}
func (ptr *QAbstractProxyModel) DisconnectSourceModelChanged() {
if ptr.Pointer() != nil {
C.QAbstractProxyModel_DisconnectSourceModelChanged(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "sourceModelChanged")
}
}
//export callbackQAbstractProxyModelSourceModelChanged
func callbackQAbstractProxyModelSourceModelChanged(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "sourceModelChanged").(func())()
}
func (ptr *QAbstractProxyModel) Submit() bool {
if ptr.Pointer() != nil {
return C.QAbstractProxyModel_Submit(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QAbstractProxyModel) SupportedDragActions() Qt__DropAction {
if ptr.Pointer() != nil {
return Qt__DropAction(C.QAbstractProxyModel_SupportedDragActions(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAbstractProxyModel) SupportedDropActions() Qt__DropAction {
if ptr.Pointer() != nil {
return Qt__DropAction(C.QAbstractProxyModel_SupportedDropActions(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAbstractProxyModel) DestroyQAbstractProxyModel() {
if ptr.Pointer() != nil {
C.QAbstractProxyModel_DestroyQAbstractProxyModel(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

34
core/qabstractproxymodel.h Executable file
View file

@ -0,0 +1,34 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QAbstractProxyModel_Buddy(QtObjectPtr ptr, QtObjectPtr index);
int QAbstractProxyModel_CanDropMimeData(QtObjectPtr ptr, QtObjectPtr data, int action, int row, int column, QtObjectPtr parent);
int QAbstractProxyModel_CanFetchMore(QtObjectPtr ptr, QtObjectPtr parent);
char* QAbstractProxyModel_Data(QtObjectPtr ptr, QtObjectPtr proxyIndex, int role);
int QAbstractProxyModel_DropMimeData(QtObjectPtr ptr, QtObjectPtr data, int action, int row, int column, QtObjectPtr parent);
void QAbstractProxyModel_FetchMore(QtObjectPtr ptr, QtObjectPtr parent);
int QAbstractProxyModel_Flags(QtObjectPtr ptr, QtObjectPtr index);
int QAbstractProxyModel_HasChildren(QtObjectPtr ptr, QtObjectPtr parent);
char* QAbstractProxyModel_HeaderData(QtObjectPtr ptr, int section, int orientation, int role);
QtObjectPtr QAbstractProxyModel_MapFromSource(QtObjectPtr ptr, QtObjectPtr sourceIndex);
QtObjectPtr QAbstractProxyModel_MapToSource(QtObjectPtr ptr, QtObjectPtr proxyIndex);
char* QAbstractProxyModel_MimeTypes(QtObjectPtr ptr);
void QAbstractProxyModel_Revert(QtObjectPtr ptr);
int QAbstractProxyModel_SetData(QtObjectPtr ptr, QtObjectPtr index, char* value, int role);
int QAbstractProxyModel_SetHeaderData(QtObjectPtr ptr, int section, int orientation, char* value, int role);
void QAbstractProxyModel_SetSourceModel(QtObjectPtr ptr, QtObjectPtr sourceModel);
QtObjectPtr QAbstractProxyModel_Sibling(QtObjectPtr ptr, int row, int column, QtObjectPtr idx);
void QAbstractProxyModel_Sort(QtObjectPtr ptr, int column, int order);
QtObjectPtr QAbstractProxyModel_SourceModel(QtObjectPtr ptr);
void QAbstractProxyModel_ConnectSourceModelChanged(QtObjectPtr ptr);
void QAbstractProxyModel_DisconnectSourceModelChanged(QtObjectPtr ptr);
int QAbstractProxyModel_Submit(QtObjectPtr ptr);
int QAbstractProxyModel_SupportedDragActions(QtObjectPtr ptr);
int QAbstractProxyModel_SupportedDropActions(QtObjectPtr ptr);
void QAbstractProxyModel_DestroyQAbstractProxyModel(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

56
core/qabstractstate.cpp Executable file
View file

@ -0,0 +1,56 @@
#include "qabstractstate.h"
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QObject>
#include <QString>
#include <QAbstractState>
#include "_cgo_export.h"
class MyQAbstractState: public QAbstractState {
public:
void Signal_ActiveChanged(bool active){callbackQAbstractStateActiveChanged(this->objectName().toUtf8().data(), active);};
void Signal_Entered(){callbackQAbstractStateEntered(this->objectName().toUtf8().data());};
void Signal_Exited(){callbackQAbstractStateExited(this->objectName().toUtf8().data());};
};
int QAbstractState_Active(QtObjectPtr ptr){
return static_cast<QAbstractState*>(ptr)->active();
}
void QAbstractState_ConnectActiveChanged(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractState*>(ptr), static_cast<void (QAbstractState::*)(bool)>(&QAbstractState::activeChanged), static_cast<MyQAbstractState*>(ptr), static_cast<void (MyQAbstractState::*)(bool)>(&MyQAbstractState::Signal_ActiveChanged));;
}
void QAbstractState_DisconnectActiveChanged(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractState*>(ptr), static_cast<void (QAbstractState::*)(bool)>(&QAbstractState::activeChanged), static_cast<MyQAbstractState*>(ptr), static_cast<void (MyQAbstractState::*)(bool)>(&MyQAbstractState::Signal_ActiveChanged));;
}
void QAbstractState_ConnectEntered(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractState*>(ptr), &QAbstractState::entered, static_cast<MyQAbstractState*>(ptr), static_cast<void (MyQAbstractState::*)()>(&MyQAbstractState::Signal_Entered));;
}
void QAbstractState_DisconnectEntered(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractState*>(ptr), &QAbstractState::entered, static_cast<MyQAbstractState*>(ptr), static_cast<void (MyQAbstractState::*)()>(&MyQAbstractState::Signal_Entered));;
}
void QAbstractState_ConnectExited(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractState*>(ptr), &QAbstractState::exited, static_cast<MyQAbstractState*>(ptr), static_cast<void (MyQAbstractState::*)()>(&MyQAbstractState::Signal_Exited));;
}
void QAbstractState_DisconnectExited(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractState*>(ptr), &QAbstractState::exited, static_cast<MyQAbstractState*>(ptr), static_cast<void (MyQAbstractState::*)()>(&MyQAbstractState::Signal_Exited));;
}
QtObjectPtr QAbstractState_Machine(QtObjectPtr ptr){
return static_cast<QAbstractState*>(ptr)->machine();
}
QtObjectPtr QAbstractState_ParentState(QtObjectPtr ptr){
return static_cast<QAbstractState*>(ptr)->parentState();
}
void QAbstractState_DestroyQAbstractState(QtObjectPtr ptr){
static_cast<QAbstractState*>(ptr)->~QAbstractState();
}

122
core/qabstractstate.go Executable file
View file

@ -0,0 +1,122 @@
package core
//#include "qabstractstate.h"
import "C"
import (
"github.com/therecipe/qt"
"unsafe"
)
type QAbstractState struct {
QObject
}
type QAbstractStateITF interface {
QObjectITF
QAbstractStatePTR() *QAbstractState
}
func PointerFromQAbstractState(ptr QAbstractStateITF) unsafe.Pointer {
if ptr != nil {
return ptr.QAbstractStatePTR().Pointer()
}
return nil
}
func QAbstractStateFromPointer(ptr unsafe.Pointer) *QAbstractState {
var n = new(QAbstractState)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QAbstractState_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QAbstractState) QAbstractStatePTR() *QAbstractState {
return ptr
}
func (ptr *QAbstractState) Active() bool {
if ptr.Pointer() != nil {
return C.QAbstractState_Active(C.QtObjectPtr(ptr.Pointer())) != 0
}
return false
}
func (ptr *QAbstractState) ConnectActiveChanged(f func(active bool)) {
if ptr.Pointer() != nil {
C.QAbstractState_ConnectActiveChanged(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "activeChanged", f)
}
}
func (ptr *QAbstractState) DisconnectActiveChanged() {
if ptr.Pointer() != nil {
C.QAbstractState_DisconnectActiveChanged(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "activeChanged")
}
}
//export callbackQAbstractStateActiveChanged
func callbackQAbstractStateActiveChanged(ptrName *C.char, active C.int) {
qt.GetSignal(C.GoString(ptrName), "activeChanged").(func(bool))(int(active) != 0)
}
func (ptr *QAbstractState) ConnectEntered(f func()) {
if ptr.Pointer() != nil {
C.QAbstractState_ConnectEntered(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "entered", f)
}
}
func (ptr *QAbstractState) DisconnectEntered() {
if ptr.Pointer() != nil {
C.QAbstractState_DisconnectEntered(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "entered")
}
}
//export callbackQAbstractStateEntered
func callbackQAbstractStateEntered(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "entered").(func())()
}
func (ptr *QAbstractState) ConnectExited(f func()) {
if ptr.Pointer() != nil {
C.QAbstractState_ConnectExited(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "exited", f)
}
}
func (ptr *QAbstractState) DisconnectExited() {
if ptr.Pointer() != nil {
C.QAbstractState_DisconnectExited(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "exited")
}
}
//export callbackQAbstractStateExited
func callbackQAbstractStateExited(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "exited").(func())()
}
func (ptr *QAbstractState) Machine() *QStateMachine {
if ptr.Pointer() != nil {
return QStateMachineFromPointer(unsafe.Pointer(C.QAbstractState_Machine(C.QtObjectPtr(ptr.Pointer()))))
}
return nil
}
func (ptr *QAbstractState) ParentState() *QState {
if ptr.Pointer() != nil {
return QStateFromPointer(unsafe.Pointer(C.QAbstractState_ParentState(C.QtObjectPtr(ptr.Pointer()))))
}
return nil
}
func (ptr *QAbstractState) DestroyQAbstractState() {
if ptr.Pointer() != nil {
C.QAbstractState_DestroyQAbstractState(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

19
core/qabstractstate.h Executable file
View file

@ -0,0 +1,19 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
int QAbstractState_Active(QtObjectPtr ptr);
void QAbstractState_ConnectActiveChanged(QtObjectPtr ptr);
void QAbstractState_DisconnectActiveChanged(QtObjectPtr ptr);
void QAbstractState_ConnectEntered(QtObjectPtr ptr);
void QAbstractState_DisconnectEntered(QtObjectPtr ptr);
void QAbstractState_ConnectExited(QtObjectPtr ptr);
void QAbstractState_DisconnectExited(QtObjectPtr ptr);
QtObjectPtr QAbstractState_Machine(QtObjectPtr ptr);
QtObjectPtr QAbstractState_ParentState(QtObjectPtr ptr);
void QAbstractState_DestroyQAbstractState(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

33
core/qabstracttablemodel.cpp Executable file
View file

@ -0,0 +1,33 @@
#include "qabstracttablemodel.h"
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QMimeData>
#include <QString>
#include <QAbstractTableModel>
#include "_cgo_export.h"
class MyQAbstractTableModel: public QAbstractTableModel {
public:
};
QtObjectPtr QAbstractTableModel_Index(QtObjectPtr ptr, int row, int column, QtObjectPtr parent){
return static_cast<QAbstractTableModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)).internalPointer();
}
int QAbstractTableModel_DropMimeData(QtObjectPtr ptr, QtObjectPtr data, int action, int row, int column, QtObjectPtr parent){
return static_cast<QAbstractTableModel*>(ptr)->dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
int QAbstractTableModel_Flags(QtObjectPtr ptr, QtObjectPtr index){
return static_cast<QAbstractTableModel*>(ptr)->flags(*static_cast<QModelIndex*>(index));
}
QtObjectPtr QAbstractTableModel_Sibling(QtObjectPtr ptr, int row, int column, QtObjectPtr idx){
return static_cast<QAbstractTableModel*>(ptr)->sibling(row, column, *static_cast<QModelIndex*>(idx)).internalPointer();
}
void QAbstractTableModel_DestroyQAbstractTableModel(QtObjectPtr ptr){
static_cast<QAbstractTableModel*>(ptr)->~QAbstractTableModel();
}

72
core/qabstracttablemodel.go Executable file
View file

@ -0,0 +1,72 @@
package core
//#include "qabstracttablemodel.h"
import "C"
import (
"github.com/therecipe/qt"
"unsafe"
)
type QAbstractTableModel struct {
QAbstractItemModel
}
type QAbstractTableModelITF interface {
QAbstractItemModelITF
QAbstractTableModelPTR() *QAbstractTableModel
}
func PointerFromQAbstractTableModel(ptr QAbstractTableModelITF) unsafe.Pointer {
if ptr != nil {
return ptr.QAbstractTableModelPTR().Pointer()
}
return nil
}
func QAbstractTableModelFromPointer(ptr unsafe.Pointer) *QAbstractTableModel {
var n = new(QAbstractTableModel)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QAbstractTableModel_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QAbstractTableModel) QAbstractTableModelPTR() *QAbstractTableModel {
return ptr
}
func (ptr *QAbstractTableModel) Index(row int, column int, parent QModelIndexITF) *QModelIndex {
if ptr.Pointer() != nil {
return QModelIndexFromPointer(unsafe.Pointer(C.QAbstractTableModel_Index(C.QtObjectPtr(ptr.Pointer()), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(parent)))))
}
return nil
}
func (ptr *QAbstractTableModel) DropMimeData(data QMimeDataITF, action Qt__DropAction, row int, column int, parent QModelIndexITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractTableModel_DropMimeData(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQMimeData(data)), C.int(action), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(parent))) != 0
}
return false
}
func (ptr *QAbstractTableModel) Flags(index QModelIndexITF) Qt__ItemFlag {
if ptr.Pointer() != nil {
return Qt__ItemFlag(C.QAbstractTableModel_Flags(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQModelIndex(index))))
}
return 0
}
func (ptr *QAbstractTableModel) Sibling(row int, column int, idx QModelIndexITF) *QModelIndex {
if ptr.Pointer() != nil {
return QModelIndexFromPointer(unsafe.Pointer(C.QAbstractTableModel_Sibling(C.QtObjectPtr(ptr.Pointer()), C.int(row), C.int(column), C.QtObjectPtr(PointerFromQModelIndex(idx)))))
}
return nil
}
func (ptr *QAbstractTableModel) DestroyQAbstractTableModel() {
if ptr.Pointer() != nil {
C.QAbstractTableModel_DestroyQAbstractTableModel(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

14
core/qabstracttablemodel.h Executable file
View file

@ -0,0 +1,14 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
QtObjectPtr QAbstractTableModel_Index(QtObjectPtr ptr, int row, int column, QtObjectPtr parent);
int QAbstractTableModel_DropMimeData(QtObjectPtr ptr, QtObjectPtr data, int action, int row, int column, QtObjectPtr parent);
int QAbstractTableModel_Flags(QtObjectPtr ptr, QtObjectPtr index);
QtObjectPtr QAbstractTableModel_Sibling(QtObjectPtr ptr, int row, int column, QtObjectPtr idx);
void QAbstractTableModel_DestroyQAbstractTableModel(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

78
core/qabstracttransition.cpp Executable file
View file

@ -0,0 +1,78 @@
#include "qabstracttransition.h"
#include <QAbstractAnimation>
#include <QAbstractState>
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QObject>
#include <QAbstractTransition>
#include "_cgo_export.h"
class MyQAbstractTransition: public QAbstractTransition {
public:
void Signal_TargetStateChanged(){callbackQAbstractTransitionTargetStateChanged(this->objectName().toUtf8().data());};
void Signal_TargetStatesChanged(){callbackQAbstractTransitionTargetStatesChanged(this->objectName().toUtf8().data());};
void Signal_Triggered(){callbackQAbstractTransitionTriggered(this->objectName().toUtf8().data());};
};
void QAbstractTransition_AddAnimation(QtObjectPtr ptr, QtObjectPtr animation){
static_cast<QAbstractTransition*>(ptr)->addAnimation(static_cast<QAbstractAnimation*>(animation));
}
QtObjectPtr QAbstractTransition_Machine(QtObjectPtr ptr){
return static_cast<QAbstractTransition*>(ptr)->machine();
}
void QAbstractTransition_RemoveAnimation(QtObjectPtr ptr, QtObjectPtr animation){
static_cast<QAbstractTransition*>(ptr)->removeAnimation(static_cast<QAbstractAnimation*>(animation));
}
void QAbstractTransition_SetTargetState(QtObjectPtr ptr, QtObjectPtr target){
static_cast<QAbstractTransition*>(ptr)->setTargetState(static_cast<QAbstractState*>(target));
}
void QAbstractTransition_SetTransitionType(QtObjectPtr ptr, int ty){
static_cast<QAbstractTransition*>(ptr)->setTransitionType(static_cast<QAbstractTransition::TransitionType>(ty));
}
QtObjectPtr QAbstractTransition_SourceState(QtObjectPtr ptr){
return static_cast<QAbstractTransition*>(ptr)->sourceState();
}
QtObjectPtr QAbstractTransition_TargetState(QtObjectPtr ptr){
return static_cast<QAbstractTransition*>(ptr)->targetState();
}
void QAbstractTransition_ConnectTargetStateChanged(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractTransition*>(ptr), &QAbstractTransition::targetStateChanged, static_cast<MyQAbstractTransition*>(ptr), static_cast<void (MyQAbstractTransition::*)()>(&MyQAbstractTransition::Signal_TargetStateChanged));;
}
void QAbstractTransition_DisconnectTargetStateChanged(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractTransition*>(ptr), &QAbstractTransition::targetStateChanged, static_cast<MyQAbstractTransition*>(ptr), static_cast<void (MyQAbstractTransition::*)()>(&MyQAbstractTransition::Signal_TargetStateChanged));;
}
void QAbstractTransition_ConnectTargetStatesChanged(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractTransition*>(ptr), &QAbstractTransition::targetStatesChanged, static_cast<MyQAbstractTransition*>(ptr), static_cast<void (MyQAbstractTransition::*)()>(&MyQAbstractTransition::Signal_TargetStatesChanged));;
}
void QAbstractTransition_DisconnectTargetStatesChanged(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractTransition*>(ptr), &QAbstractTransition::targetStatesChanged, static_cast<MyQAbstractTransition*>(ptr), static_cast<void (MyQAbstractTransition::*)()>(&MyQAbstractTransition::Signal_TargetStatesChanged));;
}
int QAbstractTransition_TransitionType(QtObjectPtr ptr){
return static_cast<QAbstractTransition*>(ptr)->transitionType();
}
void QAbstractTransition_ConnectTriggered(QtObjectPtr ptr){
QObject::connect(static_cast<QAbstractTransition*>(ptr), &QAbstractTransition::triggered, static_cast<MyQAbstractTransition*>(ptr), static_cast<void (MyQAbstractTransition::*)()>(&MyQAbstractTransition::Signal_Triggered));;
}
void QAbstractTransition_DisconnectTriggered(QtObjectPtr ptr){
QObject::disconnect(static_cast<QAbstractTransition*>(ptr), &QAbstractTransition::triggered, static_cast<MyQAbstractTransition*>(ptr), static_cast<void (MyQAbstractTransition::*)()>(&MyQAbstractTransition::Signal_Triggered));;
}
void QAbstractTransition_DestroyQAbstractTransition(QtObjectPtr ptr){
static_cast<QAbstractTransition*>(ptr)->~QAbstractTransition();
}

161
core/qabstracttransition.go Executable file
View file

@ -0,0 +1,161 @@
package core
//#include "qabstracttransition.h"
import "C"
import (
"github.com/therecipe/qt"
"unsafe"
)
type QAbstractTransition struct {
QObject
}
type QAbstractTransitionITF interface {
QObjectITF
QAbstractTransitionPTR() *QAbstractTransition
}
func PointerFromQAbstractTransition(ptr QAbstractTransitionITF) unsafe.Pointer {
if ptr != nil {
return ptr.QAbstractTransitionPTR().Pointer()
}
return nil
}
func QAbstractTransitionFromPointer(ptr unsafe.Pointer) *QAbstractTransition {
var n = new(QAbstractTransition)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QAbstractTransition_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QAbstractTransition) QAbstractTransitionPTR() *QAbstractTransition {
return ptr
}
//QAbstractTransition::TransitionType
type QAbstractTransition__TransitionType int
var (
QAbstractTransition__ExternalTransition = QAbstractTransition__TransitionType(0)
QAbstractTransition__InternalTransition = QAbstractTransition__TransitionType(1)
)
func (ptr *QAbstractTransition) AddAnimation(animation QAbstractAnimationITF) {
if ptr.Pointer() != nil {
C.QAbstractTransition_AddAnimation(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQAbstractAnimation(animation)))
}
}
func (ptr *QAbstractTransition) Machine() *QStateMachine {
if ptr.Pointer() != nil {
return QStateMachineFromPointer(unsafe.Pointer(C.QAbstractTransition_Machine(C.QtObjectPtr(ptr.Pointer()))))
}
return nil
}
func (ptr *QAbstractTransition) RemoveAnimation(animation QAbstractAnimationITF) {
if ptr.Pointer() != nil {
C.QAbstractTransition_RemoveAnimation(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQAbstractAnimation(animation)))
}
}
func (ptr *QAbstractTransition) SetTargetState(target QAbstractStateITF) {
if ptr.Pointer() != nil {
C.QAbstractTransition_SetTargetState(C.QtObjectPtr(ptr.Pointer()), C.QtObjectPtr(PointerFromQAbstractState(target)))
}
}
func (ptr *QAbstractTransition) SetTransitionType(ty QAbstractTransition__TransitionType) {
if ptr.Pointer() != nil {
C.QAbstractTransition_SetTransitionType(C.QtObjectPtr(ptr.Pointer()), C.int(ty))
}
}
func (ptr *QAbstractTransition) SourceState() *QState {
if ptr.Pointer() != nil {
return QStateFromPointer(unsafe.Pointer(C.QAbstractTransition_SourceState(C.QtObjectPtr(ptr.Pointer()))))
}
return nil
}
func (ptr *QAbstractTransition) TargetState() *QAbstractState {
if ptr.Pointer() != nil {
return QAbstractStateFromPointer(unsafe.Pointer(C.QAbstractTransition_TargetState(C.QtObjectPtr(ptr.Pointer()))))
}
return nil
}
func (ptr *QAbstractTransition) ConnectTargetStateChanged(f func()) {
if ptr.Pointer() != nil {
C.QAbstractTransition_ConnectTargetStateChanged(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "targetStateChanged", f)
}
}
func (ptr *QAbstractTransition) DisconnectTargetStateChanged() {
if ptr.Pointer() != nil {
C.QAbstractTransition_DisconnectTargetStateChanged(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "targetStateChanged")
}
}
//export callbackQAbstractTransitionTargetStateChanged
func callbackQAbstractTransitionTargetStateChanged(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "targetStateChanged").(func())()
}
func (ptr *QAbstractTransition) ConnectTargetStatesChanged(f func()) {
if ptr.Pointer() != nil {
C.QAbstractTransition_ConnectTargetStatesChanged(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "targetStatesChanged", f)
}
}
func (ptr *QAbstractTransition) DisconnectTargetStatesChanged() {
if ptr.Pointer() != nil {
C.QAbstractTransition_DisconnectTargetStatesChanged(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "targetStatesChanged")
}
}
//export callbackQAbstractTransitionTargetStatesChanged
func callbackQAbstractTransitionTargetStatesChanged(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "targetStatesChanged").(func())()
}
func (ptr *QAbstractTransition) TransitionType() QAbstractTransition__TransitionType {
if ptr.Pointer() != nil {
return QAbstractTransition__TransitionType(C.QAbstractTransition_TransitionType(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAbstractTransition) ConnectTriggered(f func()) {
if ptr.Pointer() != nil {
C.QAbstractTransition_ConnectTriggered(C.QtObjectPtr(ptr.Pointer()))
qt.ConnectSignal(ptr.ObjectName(), "triggered", f)
}
}
func (ptr *QAbstractTransition) DisconnectTriggered() {
if ptr.Pointer() != nil {
C.QAbstractTransition_DisconnectTriggered(C.QtObjectPtr(ptr.Pointer()))
qt.DisconnectSignal(ptr.ObjectName(), "triggered")
}
}
//export callbackQAbstractTransitionTriggered
func callbackQAbstractTransitionTriggered(ptrName *C.char) {
qt.GetSignal(C.GoString(ptrName), "triggered").(func())()
}
func (ptr *QAbstractTransition) DestroyQAbstractTransition() {
if ptr.Pointer() != nil {
C.QAbstractTransition_DestroyQAbstractTransition(C.QtObjectPtr(ptr.Pointer()))
ptr.SetPointer(nil)
}
}

24
core/qabstracttransition.h Executable file
View file

@ -0,0 +1,24 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
void QAbstractTransition_AddAnimation(QtObjectPtr ptr, QtObjectPtr animation);
QtObjectPtr QAbstractTransition_Machine(QtObjectPtr ptr);
void QAbstractTransition_RemoveAnimation(QtObjectPtr ptr, QtObjectPtr animation);
void QAbstractTransition_SetTargetState(QtObjectPtr ptr, QtObjectPtr target);
void QAbstractTransition_SetTransitionType(QtObjectPtr ptr, int ty);
QtObjectPtr QAbstractTransition_SourceState(QtObjectPtr ptr);
QtObjectPtr QAbstractTransition_TargetState(QtObjectPtr ptr);
void QAbstractTransition_ConnectTargetStateChanged(QtObjectPtr ptr);
void QAbstractTransition_DisconnectTargetStateChanged(QtObjectPtr ptr);
void QAbstractTransition_ConnectTargetStatesChanged(QtObjectPtr ptr);
void QAbstractTransition_DisconnectTargetStatesChanged(QtObjectPtr ptr);
int QAbstractTransition_TransitionType(QtObjectPtr ptr);
void QAbstractTransition_ConnectTriggered(QtObjectPtr ptr);
void QAbstractTransition_DisconnectTriggered(QtObjectPtr ptr);
void QAbstractTransition_DestroyQAbstractTransition(QtObjectPtr ptr);
#ifdef __cplusplus
}
#endif

8
core/qanimationgroup.cpp Executable file
View file

@ -0,0 +1,8 @@
#include "qanimationgroup.h"
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QAnimationGroup>
#include "_cgo_export.h"

37
core/qanimationgroup.go Executable file
View file

@ -0,0 +1,37 @@
package core
//#include "qanimationgroup.h"
import "C"
import (
"github.com/therecipe/qt"
"unsafe"
)
type QAnimationGroup struct {
QAbstractAnimation
}
type QAnimationGroupITF interface {
QAbstractAnimationITF
QAnimationGroupPTR() *QAnimationGroup
}
func PointerFromQAnimationGroup(ptr QAnimationGroupITF) unsafe.Pointer {
if ptr != nil {
return ptr.QAnimationGroupPTR().Pointer()
}
return nil
}
func QAnimationGroupFromPointer(ptr unsafe.Pointer) *QAnimationGroup {
var n = new(QAnimationGroup)
n.SetPointer(ptr)
if n.ObjectName() == "" {
n.SetObjectName("QAnimationGroup_" + qt.RandomIdentifier())
}
return n
}
func (ptr *QAnimationGroup) QAnimationGroupPTR() *QAnimationGroup {
return ptr
}

9
core/qanimationgroup.h Executable file
View file

@ -0,0 +1,9 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cgoutil.h"
#ifdef __cplusplus
}
#endif

20
core/qassociativeiterable.cpp Executable file
View file

@ -0,0 +1,20 @@
#include "qassociativeiterable.h"
#include <QString>
#include <QVariant>
#include <QUrl>
#include <QModelIndex>
#include <QAssociativeIterable>
#include "_cgo_export.h"
class MyQAssociativeIterable: public QAssociativeIterable {
public:
};
int QAssociativeIterable_Size(QtObjectPtr ptr){
return static_cast<QAssociativeIterable*>(ptr)->size();
}
char* QAssociativeIterable_Value(QtObjectPtr ptr, char* key){
return static_cast<QAssociativeIterable*>(ptr)->value(QVariant(key)).toString().toUtf8().data();
}

54
core/qassociativeiterable.go Executable file
View file

@ -0,0 +1,54 @@
package core
//#include "qassociativeiterable.h"
import "C"
import (
"unsafe"
)
type QAssociativeIterable struct {
ptr unsafe.Pointer
}
type QAssociativeIterableITF interface {
QAssociativeIterablePTR() *QAssociativeIterable
}
func (p *QAssociativeIterable) Pointer() unsafe.Pointer {
return p.ptr
}
func (p *QAssociativeIterable) SetPointer(ptr unsafe.Pointer) {
p.ptr = ptr
}
func PointerFromQAssociativeIterable(ptr QAssociativeIterableITF) unsafe.Pointer {
if ptr != nil {
return ptr.QAssociativeIterablePTR().Pointer()
}
return nil
}
func QAssociativeIterableFromPointer(ptr unsafe.Pointer) *QAssociativeIterable {
var n = new(QAssociativeIterable)
n.SetPointer(ptr)
return n
}
func (ptr *QAssociativeIterable) QAssociativeIterablePTR() *QAssociativeIterable {
return ptr
}
func (ptr *QAssociativeIterable) Size() int {
if ptr.Pointer() != nil {
return int(C.QAssociativeIterable_Size(C.QtObjectPtr(ptr.Pointer())))
}
return 0
}
func (ptr *QAssociativeIterable) Value(key string) string {
if ptr.Pointer() != nil {
return C.GoString(C.QAssociativeIterable_Value(C.QtObjectPtr(ptr.Pointer()), C.CString(key)))
}
return ""
}

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