2016-05-28 19:18:42 +03:00
|
|
|
// +build !minimal
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
package sensors
|
|
|
|
|
2016-08-23 23:51:01 +03:00
|
|
|
//#include <stdint.h>
|
2016-08-20 00:20:42 +03:00
|
|
|
//#include <stdlib.h>
|
2017-01-11 18:18:44 +03:00
|
|
|
//#include <string.h>
|
2016-01-08 04:44:20 +03:00
|
|
|
//#include "sensors.h"
|
|
|
|
import "C"
|
|
|
|
import (
|
2016-08-23 23:51:01 +03:00
|
|
|
"fmt"
|
2016-01-08 04:44:20 +03:00
|
|
|
"github.com/therecipe/qt"
|
|
|
|
"github.com/therecipe/qt/core"
|
2016-08-20 00:20:42 +03:00
|
|
|
"runtime"
|
2016-01-08 04:44:20 +03:00
|
|
|
"strings"
|
|
|
|
"unsafe"
|
|
|
|
)
|
|
|
|
|
2016-11-09 21:31:25 +03:00
|
|
|
func cGoUnpackString(s C.struct_QtSensors_PackedString) string {
|
|
|
|
if len := int(s.len); len == -1 {
|
|
|
|
return C.GoString(s.data)
|
|
|
|
}
|
|
|
|
return C.GoStringN(s.data, C.int(s.len))
|
|
|
|
}
|
|
|
|
|
2016-12-11 23:03:06 +03:00
|
|
|
type AndroidSensors struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type AndroidSensors_ITF interface {
|
|
|
|
AndroidSensors_PTR() *AndroidSensors
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *AndroidSensors) AndroidSensors_PTR() *AndroidSensors {
|
|
|
|
return ptr
|
2016-12-11 23:03:06 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *AndroidSensors) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-12-11 23:03:06 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *AndroidSensors) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-12-11 23:03:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromAndroidSensors(ptr AndroidSensors_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.AndroidSensors_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewAndroidSensorsFromPointer(ptr unsafe.Pointer) *AndroidSensors {
|
|
|
|
var n = new(AndroidSensors)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *AndroidSensors) DestroyAndroidSensors() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
2016-12-11 23:03:06 +03:00
|
|
|
}
|
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
//go:generate stringer -type=AndroidSensors__AndroidSensorType
|
|
|
|
//AndroidSensors::AndroidSensorType
|
|
|
|
type AndroidSensors__AndroidSensorType int64
|
2016-04-28 20:43:44 +03:00
|
|
|
|
|
|
|
const (
|
2017-01-18 21:28:40 +03:00
|
|
|
AndroidSensors__TYPE_ACCELEROMETER AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(1)
|
|
|
|
AndroidSensors__TYPE_AMBIENT_TEMPERATURE AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(13)
|
|
|
|
AndroidSensors__TYPE_GAME_ROTATION_VECTOR AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(15)
|
|
|
|
AndroidSensors__TYPE_GRAVITY AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(9)
|
|
|
|
AndroidSensors__TYPE_GYROSCOPE AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(4)
|
|
|
|
AndroidSensors__TYPE_GYROSCOPE_UNCALIBRATED AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(16)
|
|
|
|
AndroidSensors__TYPE_LIGHT AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(5)
|
|
|
|
AndroidSensors__TYPE_LINEAR_ACCELERATION AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(10)
|
|
|
|
AndroidSensors__TYPE_MAGNETIC_FIELD AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(2)
|
|
|
|
AndroidSensors__TYPE_MAGNETIC_FIELD_UNCALIBRATED AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(14)
|
|
|
|
AndroidSensors__TYPE_ORIENTATION AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(3)
|
|
|
|
AndroidSensors__TYPE_PRESSURE AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(6)
|
|
|
|
AndroidSensors__TYPE_PROXIMITY AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(8)
|
|
|
|
AndroidSensors__TYPE_RELATIVE_HUMIDITY AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(12)
|
|
|
|
AndroidSensors__TYPE_ROTATION_VECTOR AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(11)
|
|
|
|
AndroidSensors__TYPE_SIGNIFICANT_MOTION AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(17)
|
|
|
|
AndroidSensors__TYPE_TEMPERATURE AndroidSensors__AndroidSensorType = AndroidSensors__AndroidSensorType(7)
|
2016-04-28 20:43:44 +03:00
|
|
|
)
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
type QAccelerometer struct {
|
|
|
|
QSensor
|
|
|
|
}
|
|
|
|
|
|
|
|
type QAccelerometer_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QAccelerometer_PTR() *QAccelerometer
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QAccelerometer) QAccelerometer_PTR() *QAccelerometer {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QAccelerometer) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QAccelerometer) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func PointerFromQAccelerometer(ptr QAccelerometer_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QAccelerometer_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQAccelerometerFromPointer(ptr unsafe.Pointer) *QAccelerometer {
|
|
|
|
var n = new(QAccelerometer)
|
|
|
|
n.SetPointer(ptr)
|
2016-01-26 19:58:25 +03:00
|
|
|
return n
|
|
|
|
}
|
2017-01-18 21:28:40 +03:00
|
|
|
|
|
|
|
//go:generate stringer -type=QAccelerometer__AccelerationMode
|
|
|
|
//QAccelerometer::AccelerationMode
|
|
|
|
type QAccelerometer__AccelerationMode int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QAccelerometer__Combined QAccelerometer__AccelerationMode = QAccelerometer__AccelerationMode(0)
|
|
|
|
QAccelerometer__Gravity QAccelerometer__AccelerationMode = QAccelerometer__AccelerationMode(1)
|
|
|
|
QAccelerometer__User QAccelerometer__AccelerationMode = QAccelerometer__AccelerationMode(2)
|
|
|
|
)
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQAccelerometer_AccelerationModeChanged
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQAccelerometer_AccelerationModeChanged(ptr unsafe.Pointer, accelerationMode C.longlong) {
|
2017-02-15 19:48:35 +03:00
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "accelerationModeChanged"); signal != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
signal.(func(QAccelerometer__AccelerationMode))(QAccelerometer__AccelerationMode(accelerationMode))
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func (ptr *QAccelerometer) ConnectAccelerationModeChanged(f func(accelerationMode QAccelerometer__AccelerationMode)) {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "accelerationModeChanged") {
|
|
|
|
C.QAccelerometer_ConnectAccelerationModeChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "accelerationModeChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "accelerationModeChanged", func(accelerationMode QAccelerometer__AccelerationMode) {
|
|
|
|
signal.(func(QAccelerometer__AccelerationMode))(accelerationMode)
|
|
|
|
f(accelerationMode)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "accelerationModeChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QAccelerometer) DisconnectAccelerationModeChanged() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QAccelerometer_DisconnectAccelerationModeChanged(ptr.Pointer())
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "accelerationModeChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QAccelerometer) AccelerationModeChanged(accelerationMode QAccelerometer__AccelerationMode) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QAccelerometer_AccelerationModeChanged(ptr.Pointer(), C.longlong(accelerationMode))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QAccelerometer) SetAccelerationMode(accelerationMode QAccelerometer__AccelerationMode) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QAccelerometer_SetAccelerationMode(ptr.Pointer(), C.longlong(accelerationMode))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QAccelerometer) AccelerationMode() QAccelerometer__AccelerationMode {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return QAccelerometer__AccelerationMode(C.QAccelerometer_AccelerationMode(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQAccelerometer(parent core.QObject_ITF) *QAccelerometer {
|
|
|
|
var tmpValue = NewQAccelerometerFromPointer(C.QAccelerometer_NewQAccelerometer(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
//export callbackQAccelerometer_DestroyQAccelerometer
|
|
|
|
func callbackQAccelerometer_DestroyQAccelerometer(ptr unsafe.Pointer) {
|
2017-02-15 19:48:35 +03:00
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QAccelerometer"); signal != nil {
|
2016-08-27 02:22:01 +03:00
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQAccelerometerFromPointer(ptr).DestroyQAccelerometerDefault()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QAccelerometer) ConnectDestroyQAccelerometer(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QAccelerometer"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAccelerometer", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAccelerometer", f)
|
|
|
|
}
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QAccelerometer) DisconnectDestroyQAccelerometer() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QAccelerometer")
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func (ptr *QAccelerometer) DestroyQAccelerometer() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QAccelerometer_DestroyQAccelerometer(ptr.Pointer())
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
func (ptr *QAccelerometer) DestroyQAccelerometerDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QAccelerometer_DestroyQAccelerometerDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QAccelerometer) Reading() *QAccelerometerReading {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
var tmpValue = NewQAccelerometerReadingFromPointer(C.QAccelerometer_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func QAccelerometer_Type() string {
|
|
|
|
return cGoUnpackString(C.QAccelerometer_QAccelerometer_Type())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QAccelerometer) Type() string {
|
|
|
|
return cGoUnpackString(C.QAccelerometer_QAccelerometer_Type())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAccelerometerFilter struct {
|
|
|
|
QSensorFilter
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAccelerometerFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QAccelerometerFilter_PTR() *QAccelerometerFilter
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerFilter) QAccelerometerFilter_PTR() *QAccelerometerFilter {
|
|
|
|
return ptr
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQAccelerometerFilter(ptr QAccelerometerFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QAccelerometerFilter_PTR().Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAccelerometerFilterFromPointer(ptr unsafe.Pointer) *QAccelerometerFilter {
|
|
|
|
var n = new(QAccelerometerFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerFilter) DestroyQAccelerometerFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQAccelerometerFilter_Filter
|
|
|
|
func callbackQAccelerometerFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QAccelerometerReading) bool)(NewQAccelerometerReadingFromPointer(reading)))))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerFilter) ConnectFilter(f func(reading *QAccelerometerReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QAccelerometerReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QAccelerometerReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerFilter) Filter(reading QAccelerometerReading_ITF) bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QAccelerometerFilter_Filter(ptr.Pointer(), PointerFromQAccelerometerReading(reading)) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAccelerometerReading struct {
|
|
|
|
QSensorReading
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAccelerometerReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QAccelerometerReading_PTR() *QAccelerometerReading
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerReading) QAccelerometerReading_PTR() *QAccelerometerReading {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQAccelerometerReading(ptr QAccelerometerReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QAccelerometerReading_PTR().Pointer()
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAccelerometerReadingFromPointer(ptr unsafe.Pointer) *QAccelerometerReading {
|
|
|
|
var n = new(QAccelerometerReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerReading) DestroyQAccelerometerReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerReading) SetX(x float64) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QAccelerometerReading_SetX(ptr.Pointer(), C.double(x))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerReading) SetY(y float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QAccelerometerReading_SetY(ptr.Pointer(), C.double(y))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerReading) SetZ(z float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QAccelerometerReading_SetZ(ptr.Pointer(), C.double(z))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerReading) X() float64 {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QAccelerometerReading_X(ptr.Pointer()))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerReading) Y() float64 {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QAccelerometerReading_Y(ptr.Pointer()))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAccelerometerReading) Z() float64 {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QAccelerometerReading_Z(ptr.Pointer()))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAltimeter struct {
|
|
|
|
QSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAltimeter_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QAltimeter_PTR() *QAltimeter
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeter) QAltimeter_PTR() *QAltimeter {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQAltimeter(ptr QAltimeter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QAltimeter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAltimeterFromPointer(ptr unsafe.Pointer) *QAltimeter {
|
|
|
|
var n = new(QAltimeter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAltimeter(parent core.QObject_ITF) *QAltimeter {
|
|
|
|
var tmpValue = NewQAltimeterFromPointer(C.QAltimeter_NewQAltimeter(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeter) DestroyQAltimeter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QAltimeter_DestroyQAltimeter(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeter) Reading() *QAltimeterReading {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQAltimeterReadingFromPointer(C.QAltimeter_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QAltimeter_Type() string {
|
|
|
|
return cGoUnpackString(C.QAltimeter_QAltimeter_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeter) Type() string {
|
|
|
|
return cGoUnpackString(C.QAltimeter_QAltimeter_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAltimeterFilter struct {
|
|
|
|
QSensorFilter
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAltimeterFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QAltimeterFilter_PTR() *QAltimeterFilter
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterFilter) QAltimeterFilter_PTR() *QAltimeterFilter {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQAltimeterFilter(ptr QAltimeterFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QAltimeterFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAltimeterFilterFromPointer(ptr unsafe.Pointer) *QAltimeterFilter {
|
|
|
|
var n = new(QAltimeterFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterFilter) DestroyQAltimeterFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-04-28 20:43:44 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQAltimeterFilter_Filter
|
|
|
|
func callbackQAltimeterFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QAltimeterReading) bool)(NewQAltimeterReadingFromPointer(reading)))))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterFilter) ConnectFilter(f func(reading *QAltimeterReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QAltimeterReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QAltimeterReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterFilter) Filter(reading QAltimeterReading_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QAltimeterFilter_Filter(ptr.Pointer(), PointerFromQAltimeterReading(reading)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAltimeterReading struct {
|
|
|
|
QSensorReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAltimeterReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QAltimeterReading_PTR() *QAltimeterReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterReading) QAltimeterReading_PTR() *QAltimeterReading {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQAltimeterReading(ptr QAltimeterReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QAltimeterReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAltimeterReadingFromPointer(ptr unsafe.Pointer) *QAltimeterReading {
|
|
|
|
var n = new(QAltimeterReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterReading) DestroyQAltimeterReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterReading) SetAltitude(altitude float64) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QAltimeterReading_SetAltitude(ptr.Pointer(), C.double(altitude))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAltimeterReading) Altitude() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QAltimeterReading_Altitude(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAmbientLightFilter struct {
|
2016-04-28 20:43:44 +03:00
|
|
|
QSensorFilter
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAmbientLightFilter_ITF interface {
|
2016-04-28 20:43:44 +03:00
|
|
|
QSensorFilter_ITF
|
2017-02-15 19:48:35 +03:00
|
|
|
QAmbientLightFilter_PTR() *QAmbientLightFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightFilter) QAmbientLightFilter_PTR() *QAmbientLightFilter {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightFilter) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightFilter) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQAmbientLightFilter(ptr QAmbientLightFilter_ITF) unsafe.Pointer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QAmbientLightFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAmbientLightFilterFromPointer(ptr unsafe.Pointer) *QAmbientLightFilter {
|
|
|
|
var n = new(QAmbientLightFilter)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2016-01-26 19:58:25 +03:00
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightFilter) DestroyQAmbientLightFilter() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQAmbientLightFilter_Filter
|
|
|
|
func callbackQAmbientLightFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QAmbientLightReading) bool)(NewQAmbientLightReadingFromPointer(reading)))))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2016-08-23 23:51:01 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightFilter) ConnectFilter(f func(reading *QAmbientLightReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QAmbientLightReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QAmbientLightReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightFilter) DisconnectFilter() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightFilter) Filter(reading QAmbientLightReading_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QAmbientLightFilter_Filter(ptr.Pointer(), PointerFromQAmbientLightReading(reading)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAmbientLightReading struct {
|
2016-04-28 20:43:44 +03:00
|
|
|
QSensorReading
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAmbientLightReading_ITF interface {
|
2016-04-28 20:43:44 +03:00
|
|
|
QSensorReading_ITF
|
2017-02-15 19:48:35 +03:00
|
|
|
QAmbientLightReading_PTR() *QAmbientLightReading
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightReading) QAmbientLightReading_PTR() *QAmbientLightReading {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightReading) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightReading) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQAmbientLightReading(ptr QAmbientLightReading_ITF) unsafe.Pointer {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QAmbientLightReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAmbientLightReadingFromPointer(ptr unsafe.Pointer) *QAmbientLightReading {
|
|
|
|
var n = new(QAmbientLightReading)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightReading) DestroyQAmbientLightReading() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//go:generate stringer -type=QAmbientLightReading__LightLevel
|
|
|
|
//QAmbientLightReading::LightLevel
|
|
|
|
type QAmbientLightReading__LightLevel int64
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
const (
|
|
|
|
QAmbientLightReading__Undefined QAmbientLightReading__LightLevel = QAmbientLightReading__LightLevel(0)
|
|
|
|
QAmbientLightReading__Dark QAmbientLightReading__LightLevel = QAmbientLightReading__LightLevel(1)
|
|
|
|
QAmbientLightReading__Twilight QAmbientLightReading__LightLevel = QAmbientLightReading__LightLevel(2)
|
|
|
|
QAmbientLightReading__Light QAmbientLightReading__LightLevel = QAmbientLightReading__LightLevel(3)
|
|
|
|
QAmbientLightReading__Bright QAmbientLightReading__LightLevel = QAmbientLightReading__LightLevel(4)
|
|
|
|
QAmbientLightReading__Sunny QAmbientLightReading__LightLevel = QAmbientLightReading__LightLevel(5)
|
|
|
|
)
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightReading) SetLightLevel(lightLevel QAmbientLightReading__LightLevel) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QAmbientLightReading_SetLightLevel(ptr.Pointer(), C.longlong(lightLevel))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightReading) LightLevel() QAmbientLightReading__LightLevel {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return QAmbientLightReading__LightLevel(C.QAmbientLightReading_LightLevel(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAmbientLightSensor struct {
|
|
|
|
QSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAmbientLightSensor_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QAmbientLightSensor_PTR() *QAmbientLightSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightSensor) QAmbientLightSensor_PTR() *QAmbientLightSensor {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightSensor) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightSensor) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQAmbientLightSensor(ptr QAmbientLightSensor_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QAmbientLightSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAmbientLightSensorFromPointer(ptr unsafe.Pointer) *QAmbientLightSensor {
|
|
|
|
var n = new(QAmbientLightSensor)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
func NewQAmbientLightSensor(parent core.QObject_ITF) *QAmbientLightSensor {
|
|
|
|
var tmpValue = NewQAmbientLightSensorFromPointer(C.QAmbientLightSensor_NewQAmbientLightSensor(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQAmbientLightSensor_DestroyQAmbientLightSensor
|
|
|
|
func callbackQAmbientLightSensor_DestroyQAmbientLightSensor(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QAmbientLightSensor"); signal != nil {
|
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQAmbientLightSensorFromPointer(ptr).DestroyQAmbientLightSensorDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightSensor) ConnectDestroyQAmbientLightSensor(f func()) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QAmbientLightSensor"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAmbientLightSensor", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAmbientLightSensor", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightSensor) DisconnectDestroyQAmbientLightSensor() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QAmbientLightSensor")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightSensor) DestroyQAmbientLightSensor() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QAmbientLightSensor_DestroyQAmbientLightSensor(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightSensor) DestroyQAmbientLightSensorDefault() {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QAmbientLightSensor_DestroyQAmbientLightSensorDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightSensor) Reading() *QAmbientLightReading {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQAmbientLightReadingFromPointer(C.QAmbientLightSensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QAmbientLightSensor_Type() string {
|
|
|
|
return cGoUnpackString(C.QAmbientLightSensor_QAmbientLightSensor_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientLightSensor) Type() string {
|
|
|
|
return cGoUnpackString(C.QAmbientLightSensor_QAmbientLightSensor_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAmbientTemperatureFilter struct {
|
|
|
|
QSensorFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAmbientTemperatureFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QAmbientTemperatureFilter_PTR() *QAmbientTemperatureFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureFilter) QAmbientTemperatureFilter_PTR() *QAmbientTemperatureFilter {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQAmbientTemperatureFilter(ptr QAmbientTemperatureFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QAmbientTemperatureFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAmbientTemperatureFilterFromPointer(ptr unsafe.Pointer) *QAmbientTemperatureFilter {
|
|
|
|
var n = new(QAmbientTemperatureFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureFilter) DestroyQAmbientTemperatureFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
2016-08-26 20:43:21 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-04-28 20:43:44 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQAmbientTemperatureFilter_Filter
|
|
|
|
func callbackQAmbientTemperatureFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QAmbientTemperatureReading) bool)(NewQAmbientTemperatureReadingFromPointer(reading)))))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureFilter) ConnectFilter(f func(reading *QAmbientTemperatureReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QAmbientTemperatureReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QAmbientTemperatureReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureFilter) Filter(reading QAmbientTemperatureReading_ITF) bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QAmbientTemperatureFilter_Filter(ptr.Pointer(), PointerFromQAmbientTemperatureReading(reading)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAmbientTemperatureReading struct {
|
|
|
|
QSensorReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAmbientTemperatureReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QAmbientTemperatureReading_PTR() *QAmbientTemperatureReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureReading) QAmbientTemperatureReading_PTR() *QAmbientTemperatureReading {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQAmbientTemperatureReading(ptr QAmbientTemperatureReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QAmbientTemperatureReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAmbientTemperatureReadingFromPointer(ptr unsafe.Pointer) *QAmbientTemperatureReading {
|
|
|
|
var n = new(QAmbientTemperatureReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureReading) DestroyQAmbientTemperatureReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureReading) SetTemperature(temperature float64) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QAmbientTemperatureReading_SetTemperature(ptr.Pointer(), C.double(temperature))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureReading) Temperature() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QAmbientTemperatureReading_Temperature(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAmbientTemperatureSensor struct {
|
2016-04-28 20:43:44 +03:00
|
|
|
QSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QAmbientTemperatureSensor_ITF interface {
|
2016-04-28 20:43:44 +03:00
|
|
|
QSensor_ITF
|
2017-02-15 19:48:35 +03:00
|
|
|
QAmbientTemperatureSensor_PTR() *QAmbientTemperatureSensor
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureSensor) QAmbientTemperatureSensor_PTR() *QAmbientTemperatureSensor {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureSensor) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureSensor) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQAmbientTemperatureSensor(ptr QAmbientTemperatureSensor_ITF) unsafe.Pointer {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QAmbientTemperatureSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAmbientTemperatureSensorFromPointer(ptr unsafe.Pointer) *QAmbientTemperatureSensor {
|
|
|
|
var n = new(QAmbientTemperatureSensor)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQAmbientTemperatureSensor(parent core.QObject_ITF) *QAmbientTemperatureSensor {
|
|
|
|
var tmpValue = NewQAmbientTemperatureSensorFromPointer(C.QAmbientTemperatureSensor_NewQAmbientTemperatureSensor(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureSensor) DestroyQAmbientTemperatureSensor() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QAmbientTemperatureSensor_DestroyQAmbientTemperatureSensor(ptr.Pointer())
|
2016-08-26 20:43:21 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-04-28 20:43:44 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureSensor) Reading() *QAmbientTemperatureReading {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQAmbientTemperatureReadingFromPointer(C.QAmbientTemperatureSensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QAmbientTemperatureSensor_Type() string {
|
|
|
|
return cGoUnpackString(C.QAmbientTemperatureSensor_QAmbientTemperatureSensor_Type())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QAmbientTemperatureSensor) Type() string {
|
|
|
|
return cGoUnpackString(C.QAmbientTemperatureSensor_QAmbientTemperatureSensor_Type())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QCompass struct {
|
|
|
|
QSensor
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QCompass_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QCompass_PTR() *QCompass
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompass) QCompass_PTR() *QCompass {
|
|
|
|
return ptr
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompass) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompass) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQCompass(ptr QCompass_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QCompass_PTR().Pointer()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQCompassFromPointer(ptr unsafe.Pointer) *QCompass {
|
|
|
|
var n = new(QCompass)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
func NewQCompass(parent core.QObject_ITF) *QCompass {
|
|
|
|
var tmpValue = NewQCompassFromPointer(C.QCompass_NewQCompass(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQCompass_DestroyQCompass
|
|
|
|
func callbackQCompass_DestroyQCompass(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QCompass"); signal != nil {
|
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQCompassFromPointer(ptr).DestroyQCompassDefault()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompass) ConnectDestroyQCompass(f func()) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QCompass"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QCompass", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QCompass", f)
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompass) DisconnectDestroyQCompass() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QCompass")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompass) DestroyQCompass() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QCompass_DestroyQCompass(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompass) DestroyQCompassDefault() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QCompass_DestroyQCompassDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompass) Reading() *QCompassReading {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQCompassReadingFromPointer(C.QCompass_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QCompass_Type() string {
|
|
|
|
return cGoUnpackString(C.QCompass_QCompass_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompass) Type() string {
|
|
|
|
return cGoUnpackString(C.QCompass_QCompass_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QCompassFilter struct {
|
|
|
|
QSensorFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QCompassFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QCompassFilter_PTR() *QCompassFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassFilter) QCompassFilter_PTR() *QCompassFilter {
|
|
|
|
return ptr
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQCompassFilter(ptr QCompassFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QCompassFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQCompassFilterFromPointer(ptr unsafe.Pointer) *QCompassFilter {
|
|
|
|
var n = new(QCompassFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassFilter) DestroyQCompassFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQCompassFilter_Filter
|
|
|
|
func callbackQCompassFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QCompassReading) bool)(NewQCompassReadingFromPointer(reading)))))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassFilter) ConnectFilter(f func(reading *QCompassReading) bool) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QCompassReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QCompassReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassFilter) DisconnectFilter() {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassFilter) Filter(reading QCompassReading_ITF) bool {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QCompassFilter_Filter(ptr.Pointer(), PointerFromQCompassReading(reading)) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QCompassReading struct {
|
|
|
|
QSensorReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QCompassReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QCompassReading_PTR() *QCompassReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassReading) QCompassReading_PTR() *QCompassReading {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQCompassReading(ptr QCompassReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QCompassReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQCompassReadingFromPointer(ptr unsafe.Pointer) *QCompassReading {
|
|
|
|
var n = new(QCompassReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassReading) DestroyQCompassReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassReading) SetAzimuth(azimuth float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QCompassReading_SetAzimuth(ptr.Pointer(), C.double(azimuth))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassReading) SetCalibrationLevel(calibrationLevel float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QCompassReading_SetCalibrationLevel(ptr.Pointer(), C.double(calibrationLevel))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassReading) Azimuth() float64 {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QCompassReading_Azimuth(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QCompassReading) CalibrationLevel() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QCompassReading_CalibrationLevel(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QDistanceFilter struct {
|
|
|
|
QSensorFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QDistanceFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QDistanceFilter_PTR() *QDistanceFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceFilter) QDistanceFilter_PTR() *QDistanceFilter {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQDistanceFilter(ptr QDistanceFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QDistanceFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQDistanceFilterFromPointer(ptr unsafe.Pointer) *QDistanceFilter {
|
|
|
|
var n = new(QDistanceFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceFilter) DestroyQDistanceFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
2016-08-26 20:43:21 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-04-30 20:03:25 +03:00
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQDistanceFilter_Filter
|
|
|
|
func callbackQDistanceFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QDistanceReading) bool)(NewQDistanceReadingFromPointer(reading)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceFilter) ConnectFilter(f func(reading *QDistanceReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QDistanceReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QDistanceReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceFilter) Filter(reading QDistanceReading_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QDistanceFilter_Filter(ptr.Pointer(), PointerFromQDistanceReading(reading)) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QDistanceReading struct {
|
|
|
|
QSensorReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QDistanceReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QDistanceReading_PTR() *QDistanceReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceReading) QDistanceReading_PTR() *QDistanceReading {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQDistanceReading(ptr QDistanceReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QDistanceReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQDistanceReadingFromPointer(ptr unsafe.Pointer) *QDistanceReading {
|
|
|
|
var n = new(QDistanceReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceReading) DestroyQDistanceReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceReading) SetDistance(distance float64) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QDistanceReading_SetDistance(ptr.Pointer(), C.double(distance))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceReading) Distance() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QDistanceReading_Distance(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QDistanceSensor struct {
|
|
|
|
QSensor
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QDistanceSensor_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QDistanceSensor_PTR() *QDistanceSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceSensor) QDistanceSensor_PTR() *QDistanceSensor {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceSensor) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceSensor) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQDistanceSensor(ptr QDistanceSensor_ITF) unsafe.Pointer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QDistanceSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQDistanceSensorFromPointer(ptr unsafe.Pointer) *QDistanceSensor {
|
|
|
|
var n = new(QDistanceSensor)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2016-01-26 19:58:25 +03:00
|
|
|
return n
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQDistanceSensor(parent core.QObject_ITF) *QDistanceSensor {
|
|
|
|
var tmpValue = NewQDistanceSensorFromPointer(C.QDistanceSensor_NewQDistanceSensor(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceSensor) DestroyQDistanceSensor() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QDistanceSensor_DestroyQDistanceSensor(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceSensor) Reading() *QDistanceReading {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQDistanceReadingFromPointer(C.QDistanceSensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QDistanceSensor_Type() string {
|
|
|
|
return cGoUnpackString(C.QDistanceSensor_QDistanceSensor_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QDistanceSensor) Type() string {
|
|
|
|
return cGoUnpackString(C.QDistanceSensor_QDistanceSensor_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QGyroscope struct {
|
|
|
|
QSensor
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QGyroscope_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QGyroscope_PTR() *QGyroscope
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscope) QGyroscope_PTR() *QGyroscope {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscope) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscope) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQGyroscope(ptr QGyroscope_ITF) unsafe.Pointer {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QGyroscope_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQGyroscopeFromPointer(ptr unsafe.Pointer) *QGyroscope {
|
|
|
|
var n = new(QGyroscope)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQGyroscope(parent core.QObject_ITF) *QGyroscope {
|
|
|
|
var tmpValue = NewQGyroscopeFromPointer(C.QGyroscope_NewQGyroscope(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQGyroscope_DestroyQGyroscope
|
|
|
|
func callbackQGyroscope_DestroyQGyroscope(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QGyroscope"); signal != nil {
|
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQGyroscopeFromPointer(ptr).DestroyQGyroscopeDefault()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscope) ConnectDestroyQGyroscope(f func()) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QGyroscope"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGyroscope", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGyroscope", f)
|
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscope) DisconnectDestroyQGyroscope() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QGyroscope")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscope) DestroyQGyroscope() {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QGyroscope_DestroyQGyroscope(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscope) DestroyQGyroscopeDefault() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QGyroscope_DestroyQGyroscopeDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscope) Reading() *QGyroscopeReading {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQGyroscopeReadingFromPointer(C.QGyroscope_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QGyroscope_Type() string {
|
|
|
|
return cGoUnpackString(C.QGyroscope_QGyroscope_Type())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscope) Type() string {
|
|
|
|
return cGoUnpackString(C.QGyroscope_QGyroscope_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QGyroscopeFilter struct {
|
|
|
|
QSensorFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QGyroscopeFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QGyroscopeFilter_PTR() *QGyroscopeFilter
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeFilter) QGyroscopeFilter_PTR() *QGyroscopeFilter {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQGyroscopeFilter(ptr QGyroscopeFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QGyroscopeFilter_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQGyroscopeFilterFromPointer(ptr unsafe.Pointer) *QGyroscopeFilter {
|
|
|
|
var n = new(QGyroscopeFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeFilter) DestroyQGyroscopeFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQGyroscopeFilter_Filter
|
|
|
|
func callbackQGyroscopeFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QGyroscopeReading) bool)(NewQGyroscopeReadingFromPointer(reading)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeFilter) ConnectFilter(f func(reading *QGyroscopeReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QGyroscopeReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QGyroscopeReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeFilter) Filter(reading QGyroscopeReading_ITF) bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QGyroscopeFilter_Filter(ptr.Pointer(), PointerFromQGyroscopeReading(reading)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QGyroscopeReading struct {
|
|
|
|
QSensorReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QGyroscopeReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QGyroscopeReading_PTR() *QGyroscopeReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeReading) QGyroscopeReading_PTR() *QGyroscopeReading {
|
|
|
|
return ptr
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQGyroscopeReading(ptr QGyroscopeReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QGyroscopeReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQGyroscopeReadingFromPointer(ptr unsafe.Pointer) *QGyroscopeReading {
|
|
|
|
var n = new(QGyroscopeReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeReading) DestroyQGyroscopeReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeReading) SetX(x float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QGyroscopeReading_SetX(ptr.Pointer(), C.double(x))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeReading) SetY(y float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QGyroscopeReading_SetY(ptr.Pointer(), C.double(y))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeReading) SetZ(z float64) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QGyroscopeReading_SetZ(ptr.Pointer(), C.double(z))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeReading) X() float64 {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QGyroscopeReading_X(ptr.Pointer()))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeReading) Y() float64 {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return float64(C.QGyroscopeReading_Y(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QGyroscopeReading) Z() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QGyroscopeReading_Z(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QHolsterFilter struct {
|
|
|
|
QSensorFilter
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QHolsterFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QHolsterFilter_PTR() *QHolsterFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterFilter) QHolsterFilter_PTR() *QHolsterFilter {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQHolsterFilter(ptr QHolsterFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QHolsterFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQHolsterFilterFromPointer(ptr unsafe.Pointer) *QHolsterFilter {
|
|
|
|
var n = new(QHolsterFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterFilter) DestroyQHolsterFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQHolsterFilter_Filter
|
|
|
|
func callbackQHolsterFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QHolsterReading) bool)(NewQHolsterReadingFromPointer(reading)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterFilter) ConnectFilter(f func(reading *QHolsterReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QHolsterReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QHolsterReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterFilter) Filter(reading QHolsterReading_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QHolsterFilter_Filter(ptr.Pointer(), PointerFromQHolsterReading(reading)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QHolsterReading struct {
|
|
|
|
QSensorReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QHolsterReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QHolsterReading_PTR() *QHolsterReading
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterReading) QHolsterReading_PTR() *QHolsterReading {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterReading) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterReading) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQHolsterReading(ptr QHolsterReading_ITF) unsafe.Pointer {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QHolsterReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQHolsterReadingFromPointer(ptr unsafe.Pointer) *QHolsterReading {
|
|
|
|
var n = new(QHolsterReading)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterReading) DestroyQHolsterReading() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterReading) SetHolstered(holstered bool) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QHolsterReading_SetHolstered(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(holstered))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterReading) Holstered() bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QHolsterReading_Holstered(ptr.Pointer()) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return false
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QHolsterSensor struct {
|
|
|
|
QSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QHolsterSensor_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QHolsterSensor_PTR() *QHolsterSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterSensor) QHolsterSensor_PTR() *QHolsterSensor {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterSensor) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterSensor) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQHolsterSensor(ptr QHolsterSensor_ITF) unsafe.Pointer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QHolsterSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQHolsterSensorFromPointer(ptr unsafe.Pointer) *QHolsterSensor {
|
|
|
|
var n = new(QHolsterSensor)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2016-01-26 19:58:25 +03:00
|
|
|
return n
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQHolsterSensor(parent core.QObject_ITF) *QHolsterSensor {
|
|
|
|
var tmpValue = NewQHolsterSensorFromPointer(C.QHolsterSensor_NewQHolsterSensor(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
2016-01-26 19:58:25 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterSensor) DestroyQHolsterSensor() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QHolsterSensor_DestroyQHolsterSensor(ptr.Pointer())
|
2017-01-14 02:36:20 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterSensor) Reading() *QHolsterReading {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQHolsterReadingFromPointer(C.QHolsterSensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QHolsterSensor_Type() string {
|
|
|
|
return cGoUnpackString(C.QHolsterSensor_QHolsterSensor_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QHolsterSensor) Type() string {
|
|
|
|
return cGoUnpackString(C.QHolsterSensor_QHolsterSensor_Type())
|
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QIRProximityFilter struct {
|
|
|
|
QSensorFilter
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QIRProximityFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QIRProximityFilter_PTR() *QIRProximityFilter
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximityFilter) QIRProximityFilter_PTR() *QIRProximityFilter {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximityFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximityFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQIRProximityFilter(ptr QIRProximityFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QIRProximityFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQIRProximityFilterFromPointer(ptr unsafe.Pointer) *QIRProximityFilter {
|
|
|
|
var n = new(QIRProximityFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QIRProximityFilter) DestroyQIRProximityFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQIRProximityFilter_Filter
|
|
|
|
func callbackQIRProximityFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QIRProximityReading) bool)(NewQIRProximityReadingFromPointer(reading)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximityFilter) ConnectFilter(f func(reading *QIRProximityReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QIRProximityReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QIRProximityReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximityFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximityFilter) Filter(reading QIRProximityReading_ITF) bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QIRProximityFilter_Filter(ptr.Pointer(), PointerFromQIRProximityReading(reading)) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QIRProximityReading struct {
|
|
|
|
QSensorReading
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QIRProximityReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QIRProximityReading_PTR() *QIRProximityReading
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximityReading) QIRProximityReading_PTR() *QIRProximityReading {
|
|
|
|
return ptr
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximityReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximityReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQIRProximityReading(ptr QIRProximityReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QIRProximityReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQIRProximityReadingFromPointer(ptr unsafe.Pointer) *QIRProximityReading {
|
|
|
|
var n = new(QIRProximityReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximityReading) DestroyQIRProximityReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximityReading) SetReflectance(reflectance float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QIRProximityReading_SetReflectance(ptr.Pointer(), C.double(reflectance))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximityReading) Reflectance() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QIRProximityReading_Reflectance(ptr.Pointer()))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QIRProximitySensor struct {
|
|
|
|
QSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QIRProximitySensor_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QIRProximitySensor_PTR() *QIRProximitySensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximitySensor) QIRProximitySensor_PTR() *QIRProximitySensor {
|
|
|
|
return ptr
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximitySensor) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximitySensor) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQIRProximitySensor(ptr QIRProximitySensor_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QIRProximitySensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQIRProximitySensorFromPointer(ptr unsafe.Pointer) *QIRProximitySensor {
|
|
|
|
var n = new(QIRProximitySensor)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
func NewQIRProximitySensor(parent core.QObject_ITF) *QIRProximitySensor {
|
|
|
|
var tmpValue = NewQIRProximitySensorFromPointer(C.QIRProximitySensor_NewQIRProximitySensor(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQIRProximitySensor_DestroyQIRProximitySensor
|
|
|
|
func callbackQIRProximitySensor_DestroyQIRProximitySensor(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QIRProximitySensor"); signal != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
signal.(func())()
|
2016-04-30 20:03:25 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQIRProximitySensorFromPointer(ptr).DestroyQIRProximitySensorDefault()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximitySensor) ConnectDestroyQIRProximitySensor(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QIRProximitySensor"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QIRProximitySensor", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QIRProximitySensor", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximitySensor) DisconnectDestroyQIRProximitySensor() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QIRProximitySensor")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximitySensor) DestroyQIRProximitySensor() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QIRProximitySensor_DestroyQIRProximitySensor(ptr.Pointer())
|
2016-08-26 20:43:21 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximitySensor) DestroyQIRProximitySensorDefault() {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QIRProximitySensor_DestroyQIRProximitySensorDefault(ptr.Pointer())
|
2016-08-26 20:43:21 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-04-30 20:03:25 +03:00
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximitySensor) Reading() *QIRProximityReading {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var tmpValue = NewQIRProximityReadingFromPointer(C.QIRProximitySensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QIRProximitySensor_Type() string {
|
|
|
|
return cGoUnpackString(C.QIRProximitySensor_QIRProximitySensor_Type())
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QIRProximitySensor) Type() string {
|
|
|
|
return cGoUnpackString(C.QIRProximitySensor_QIRProximitySensor_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QLightFilter struct {
|
|
|
|
QSensorFilter
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QLightFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QLightFilter_PTR() *QLightFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightFilter) QLightFilter_PTR() *QLightFilter {
|
|
|
|
return ptr
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QLightFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQLightFilter(ptr QLightFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QLightFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQLightFilterFromPointer(ptr unsafe.Pointer) *QLightFilter {
|
|
|
|
var n = new(QLightFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QLightFilter) DestroyQLightFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQLightFilter_Filter
|
|
|
|
func callbackQLightFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QLightReading) bool)(NewQLightReadingFromPointer(reading)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightFilter) ConnectFilter(f func(reading *QLightReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QLightReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QLightReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightFilter) Filter(reading QLightReading_ITF) bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QLightFilter_Filter(ptr.Pointer(), PointerFromQLightReading(reading)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QLightReading struct {
|
|
|
|
QSensorReading
|
|
|
|
}
|
|
|
|
|
|
|
|
type QLightReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QLightReading_PTR() *QLightReading
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightReading) QLightReading_PTR() *QLightReading {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QLightReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQLightReading(ptr QLightReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QLightReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQLightReadingFromPointer(ptr unsafe.Pointer) *QLightReading {
|
|
|
|
var n = new(QLightReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightReading) DestroyQLightReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightReading) SetLux(lux float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QLightReading_SetLux(ptr.Pointer(), C.double(lux))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightReading) Lux() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QLightReading_Lux(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QLightSensor struct {
|
2016-01-08 04:44:20 +03:00
|
|
|
QSensor
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QLightSensor_ITF interface {
|
2016-01-08 04:44:20 +03:00
|
|
|
QSensor_ITF
|
2017-02-15 19:48:35 +03:00
|
|
|
QLightSensor_PTR() *QLightSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightSensor) QLightSensor_PTR() *QLightSensor {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightSensor) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightSensor) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQLightSensor(ptr QLightSensor_ITF) unsafe.Pointer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QLightSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQLightSensorFromPointer(ptr unsafe.Pointer) *QLightSensor {
|
|
|
|
var n = new(QLightSensor)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2016-01-26 19:58:25 +03:00
|
|
|
return n
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQLightSensor(parent core.QObject_ITF) *QLightSensor {
|
|
|
|
var tmpValue = NewQLightSensorFromPointer(C.QLightSensor_NewQLightSensor(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQLightSensor_FieldOfViewChanged
|
|
|
|
func callbackQLightSensor_FieldOfViewChanged(ptr unsafe.Pointer, fieldOfView C.double) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "fieldOfViewChanged"); signal != nil {
|
|
|
|
signal.(func(float64))(float64(fieldOfView))
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QLightSensor) ConnectFieldOfViewChanged(f func(fieldOfView float64)) {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "fieldOfViewChanged") {
|
|
|
|
C.QLightSensor_ConnectFieldOfViewChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "fieldOfViewChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fieldOfViewChanged", func(fieldOfView float64) {
|
|
|
|
signal.(func(float64))(fieldOfView)
|
|
|
|
f(fieldOfView)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fieldOfViewChanged", f)
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QLightSensor) DisconnectFieldOfViewChanged() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QLightSensor_DisconnectFieldOfViewChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "fieldOfViewChanged")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QLightSensor) FieldOfViewChanged(fieldOfView float64) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QLightSensor_FieldOfViewChanged(ptr.Pointer(), C.double(fieldOfView))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QLightSensor) SetFieldOfView(fieldOfView float64) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QLightSensor_SetFieldOfView(ptr.Pointer(), C.double(fieldOfView))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQLightSensor_DestroyQLightSensor
|
|
|
|
func callbackQLightSensor_DestroyQLightSensor(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QLightSensor"); signal != nil {
|
2016-08-27 02:22:01 +03:00
|
|
|
signal.(func())()
|
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQLightSensorFromPointer(ptr).DestroyQLightSensorDefault()
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightSensor) ConnectDestroyQLightSensor(f func()) {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QLightSensor"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QLightSensor", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QLightSensor", f)
|
|
|
|
}
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightSensor) DisconnectDestroyQLightSensor() {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QLightSensor")
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightSensor) DestroyQLightSensor() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QLightSensor_DestroyQLightSensor(ptr.Pointer())
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightSensor) DestroyQLightSensorDefault() {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QLightSensor_DestroyQLightSensorDefault(ptr.Pointer())
|
2016-08-27 02:22:01 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightSensor) Reading() *QLightReading {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQLightReadingFromPointer(C.QLightSensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightSensor) FieldOfView() float64 {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return float64(C.QLightSensor_FieldOfView(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QLightSensor_Type() string {
|
|
|
|
return cGoUnpackString(C.QLightSensor_QLightSensor_Type())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QLightSensor) Type() string {
|
|
|
|
return cGoUnpackString(C.QLightSensor_QLightSensor_Type())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QMagnetometer struct {
|
|
|
|
QSensor
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QMagnetometer_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QMagnetometer_PTR() *QMagnetometer
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) QMagnetometer_PTR() *QMagnetometer {
|
|
|
|
return ptr
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQMagnetometer(ptr QMagnetometer_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QMagnetometer_PTR().Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQMagnetometerFromPointer(ptr unsafe.Pointer) *QMagnetometer {
|
|
|
|
var n = new(QMagnetometer)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQMagnetometer(parent core.QObject_ITF) *QMagnetometer {
|
|
|
|
var tmpValue = NewQMagnetometerFromPointer(C.QMagnetometer_NewQMagnetometer(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQMagnetometer_ReturnGeoValuesChanged
|
|
|
|
func callbackQMagnetometer_ReturnGeoValuesChanged(ptr unsafe.Pointer, returnGeoValues C.char) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "returnGeoValuesChanged"); signal != nil {
|
|
|
|
signal.(func(bool))(int8(returnGeoValues) != 0)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) ConnectReturnGeoValuesChanged(f func(returnGeoValues bool)) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "returnGeoValuesChanged") {
|
|
|
|
C.QMagnetometer_ConnectReturnGeoValuesChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "returnGeoValuesChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "returnGeoValuesChanged", func(returnGeoValues bool) {
|
|
|
|
signal.(func(bool))(returnGeoValues)
|
|
|
|
f(returnGeoValues)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "returnGeoValuesChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) DisconnectReturnGeoValuesChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QMagnetometer_DisconnectReturnGeoValuesChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "returnGeoValuesChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) ReturnGeoValuesChanged(returnGeoValues bool) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QMagnetometer_ReturnGeoValuesChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(returnGeoValues))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) SetReturnGeoValues(returnGeoValues bool) {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QMagnetometer_SetReturnGeoValues(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(returnGeoValues))))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQMagnetometer_DestroyQMagnetometer
|
|
|
|
func callbackQMagnetometer_DestroyQMagnetometer(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMagnetometer"); signal != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
signal.(func())()
|
2016-04-30 20:03:25 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQMagnetometerFromPointer(ptr).DestroyQMagnetometerDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) ConnectDestroyQMagnetometer(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMagnetometer"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMagnetometer", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMagnetometer", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) DisconnectDestroyQMagnetometer() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMagnetometer")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) DestroyQMagnetometer() {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QMagnetometer_DestroyQMagnetometer(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) DestroyQMagnetometerDefault() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QMagnetometer_DestroyQMagnetometerDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) Reading() *QMagnetometerReading {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQMagnetometerReadingFromPointer(C.QMagnetometer_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) ReturnGeoValues() bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QMagnetometer_ReturnGeoValues(ptr.Pointer()) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QMagnetometer_Type() string {
|
|
|
|
return cGoUnpackString(C.QMagnetometer_QMagnetometer_Type())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometer) Type() string {
|
|
|
|
return cGoUnpackString(C.QMagnetometer_QMagnetometer_Type())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QMagnetometerFilter struct {
|
|
|
|
QSensorFilter
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QMagnetometerFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QMagnetometerFilter_PTR() *QMagnetometerFilter
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerFilter) QMagnetometerFilter_PTR() *QMagnetometerFilter {
|
|
|
|
return ptr
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQMagnetometerFilter(ptr QMagnetometerFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QMagnetometerFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQMagnetometerFilterFromPointer(ptr unsafe.Pointer) *QMagnetometerFilter {
|
|
|
|
var n = new(QMagnetometerFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerFilter) DestroyQMagnetometerFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQMagnetometerFilter_Filter
|
|
|
|
func callbackQMagnetometerFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QMagnetometerReading) bool)(NewQMagnetometerReadingFromPointer(reading)))))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-26 19:58:25 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerFilter) ConnectFilter(f func(reading *QMagnetometerReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QMagnetometerReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QMagnetometerReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerFilter) DisconnectFilter() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerFilter) Filter(reading QMagnetometerReading_ITF) bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QMagnetometerFilter_Filter(ptr.Pointer(), PointerFromQMagnetometerReading(reading)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QMagnetometerReading struct {
|
|
|
|
QSensorReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QMagnetometerReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QMagnetometerReading_PTR() *QMagnetometerReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerReading) QMagnetometerReading_PTR() *QMagnetometerReading {
|
|
|
|
return ptr
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQMagnetometerReading(ptr QMagnetometerReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QMagnetometerReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQMagnetometerReadingFromPointer(ptr unsafe.Pointer) *QMagnetometerReading {
|
|
|
|
var n = new(QMagnetometerReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerReading) DestroyQMagnetometerReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerReading) SetCalibrationLevel(calibrationLevel float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QMagnetometerReading_SetCalibrationLevel(ptr.Pointer(), C.double(calibrationLevel))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerReading) SetX(x float64) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QMagnetometerReading_SetX(ptr.Pointer(), C.double(x))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerReading) SetY(y float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QMagnetometerReading_SetY(ptr.Pointer(), C.double(y))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerReading) SetZ(z float64) {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QMagnetometerReading_SetZ(ptr.Pointer(), C.double(z))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerReading) CalibrationLevel() float64 {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return float64(C.QMagnetometerReading_CalibrationLevel(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerReading) X() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QMagnetometerReading_X(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerReading) Y() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QMagnetometerReading_Y(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QMagnetometerReading) Z() float64 {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QMagnetometerReading_Z(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QOrientationFilter struct {
|
|
|
|
QSensorFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QOrientationFilter_ITF interface {
|
2016-04-28 20:43:44 +03:00
|
|
|
QSensorFilter_ITF
|
2017-02-15 19:48:35 +03:00
|
|
|
QOrientationFilter_PTR() *QOrientationFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationFilter) QOrientationFilter_PTR() *QOrientationFilter {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationFilter) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationFilter) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQOrientationFilter(ptr QOrientationFilter_ITF) unsafe.Pointer {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QOrientationFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQOrientationFilterFromPointer(ptr unsafe.Pointer) *QOrientationFilter {
|
|
|
|
var n = new(QOrientationFilter)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationFilter) DestroyQOrientationFilter() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQOrientationFilter_Filter
|
|
|
|
func callbackQOrientationFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QOrientationReading) bool)(NewQOrientationReadingFromPointer(reading)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2016-08-23 23:51:01 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationFilter) ConnectFilter(f func(reading *QOrientationReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QOrientationReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QOrientationReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationFilter) Filter(reading QOrientationReading_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QOrientationFilter_Filter(ptr.Pointer(), PointerFromQOrientationReading(reading)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QOrientationReading struct {
|
2016-04-28 20:43:44 +03:00
|
|
|
QSensorReading
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QOrientationReading_ITF interface {
|
2016-04-28 20:43:44 +03:00
|
|
|
QSensorReading_ITF
|
2017-02-15 19:48:35 +03:00
|
|
|
QOrientationReading_PTR() *QOrientationReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationReading) QOrientationReading_PTR() *QOrientationReading {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationReading) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationReading) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQOrientationReading(ptr QOrientationReading_ITF) unsafe.Pointer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QOrientationReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQOrientationReadingFromPointer(ptr unsafe.Pointer) *QOrientationReading {
|
|
|
|
var n = new(QOrientationReading)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2016-01-26 19:58:25 +03:00
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationReading) DestroyQOrientationReading() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//go:generate stringer -type=QOrientationReading__Orientation
|
|
|
|
//QOrientationReading::Orientation
|
|
|
|
type QOrientationReading__Orientation int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QOrientationReading__Undefined QOrientationReading__Orientation = QOrientationReading__Orientation(0)
|
|
|
|
QOrientationReading__TopUp QOrientationReading__Orientation = QOrientationReading__Orientation(1)
|
|
|
|
QOrientationReading__TopDown QOrientationReading__Orientation = QOrientationReading__Orientation(2)
|
|
|
|
QOrientationReading__LeftUp QOrientationReading__Orientation = QOrientationReading__Orientation(3)
|
|
|
|
QOrientationReading__RightUp QOrientationReading__Orientation = QOrientationReading__Orientation(4)
|
|
|
|
QOrientationReading__FaceUp QOrientationReading__Orientation = QOrientationReading__Orientation(5)
|
|
|
|
QOrientationReading__FaceDown QOrientationReading__Orientation = QOrientationReading__Orientation(6)
|
|
|
|
)
|
|
|
|
|
|
|
|
func (ptr *QOrientationReading) SetOrientation(orientation QOrientationReading__Orientation) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QOrientationReading_SetOrientation(ptr.Pointer(), C.longlong(orientation))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationReading) Orientation() QOrientationReading__Orientation {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return QOrientationReading__Orientation(C.QOrientationReading_Orientation(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QOrientationSensor struct {
|
|
|
|
QSensor
|
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QOrientationSensor_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QOrientationSensor_PTR() *QOrientationSensor
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationSensor) QOrientationSensor_PTR() *QOrientationSensor {
|
|
|
|
return ptr
|
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationSensor) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationSensor) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQOrientationSensor(ptr QOrientationSensor_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QOrientationSensor_PTR().Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQOrientationSensorFromPointer(ptr unsafe.Pointer) *QOrientationSensor {
|
|
|
|
var n = new(QOrientationSensor)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
func NewQOrientationSensor(parent core.QObject_ITF) *QOrientationSensor {
|
|
|
|
var tmpValue = NewQOrientationSensorFromPointer(C.QOrientationSensor_NewQOrientationSensor(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQOrientationSensor_DestroyQOrientationSensor
|
|
|
|
func callbackQOrientationSensor_DestroyQOrientationSensor(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QOrientationSensor"); signal != nil {
|
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQOrientationSensorFromPointer(ptr).DestroyQOrientationSensorDefault()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationSensor) ConnectDestroyQOrientationSensor(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QOrientationSensor"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QOrientationSensor", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QOrientationSensor", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationSensor) DisconnectDestroyQOrientationSensor() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QOrientationSensor")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationSensor) DestroyQOrientationSensor() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QOrientationSensor_DestroyQOrientationSensor(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationSensor) DestroyQOrientationSensorDefault() {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QOrientationSensor_DestroyQOrientationSensorDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationSensor) Reading() *QOrientationReading {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var tmpValue = NewQOrientationReadingFromPointer(C.QOrientationSensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QOrientationSensor_Type() string {
|
|
|
|
return cGoUnpackString(C.QOrientationSensor_QOrientationSensor_Type())
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QOrientationSensor) Type() string {
|
|
|
|
return cGoUnpackString(C.QOrientationSensor_QOrientationSensor_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QPressureFilter struct {
|
|
|
|
QSensorFilter
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QPressureFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QPressureFilter_PTR() *QPressureFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureFilter) QPressureFilter_PTR() *QPressureFilter {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQPressureFilter(ptr QPressureFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QPressureFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQPressureFilterFromPointer(ptr unsafe.Pointer) *QPressureFilter {
|
|
|
|
var n = new(QPressureFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureFilter) DestroyQPressureFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQPressureFilter_Filter
|
|
|
|
func callbackQPressureFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QPressureReading) bool)(NewQPressureReadingFromPointer(reading)))))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureFilter) ConnectFilter(f func(reading *QPressureReading) bool) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QPressureReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QPressureReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureFilter) Filter(reading QPressureReading_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QPressureFilter_Filter(ptr.Pointer(), PointerFromQPressureReading(reading)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QPressureReading struct {
|
|
|
|
QSensorReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QPressureReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QPressureReading_PTR() *QPressureReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureReading) QPressureReading_PTR() *QPressureReading {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQPressureReading(ptr QPressureReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QPressureReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQPressureReadingFromPointer(ptr unsafe.Pointer) *QPressureReading {
|
|
|
|
var n = new(QPressureReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureReading) DestroyQPressureReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureReading) SetPressure(pressure float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QPressureReading_SetPressure(ptr.Pointer(), C.double(pressure))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureReading) SetTemperature(temperature float64) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QPressureReading_SetTemperature(ptr.Pointer(), C.double(temperature))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureReading) Pressure() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QPressureReading_Pressure(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureReading) Temperature() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QPressureReading_Temperature(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QPressureSensor struct {
|
2016-01-08 04:44:20 +03:00
|
|
|
QSensor
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QPressureSensor_ITF interface {
|
2016-01-08 04:44:20 +03:00
|
|
|
QSensor_ITF
|
2017-02-15 19:48:35 +03:00
|
|
|
QPressureSensor_PTR() *QPressureSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureSensor) QPressureSensor_PTR() *QPressureSensor {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureSensor) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureSensor) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQPressureSensor(ptr QPressureSensor_ITF) unsafe.Pointer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QPressureSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQPressureSensorFromPointer(ptr unsafe.Pointer) *QPressureSensor {
|
|
|
|
var n = new(QPressureSensor)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2016-01-26 19:58:25 +03:00
|
|
|
return n
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQPressureSensor(parent core.QObject_ITF) *QPressureSensor {
|
|
|
|
var tmpValue = NewQPressureSensorFromPointer(C.QPressureSensor_NewQPressureSensor(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureSensor) DestroyQPressureSensor() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QPressureSensor_DestroyQPressureSensor(ptr.Pointer())
|
2016-08-26 20:43:21 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureSensor) Reading() *QPressureReading {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQPressureReadingFromPointer(C.QPressureSensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QPressureSensor_Type() string {
|
|
|
|
return cGoUnpackString(C.QPressureSensor_QPressureSensor_Type())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QPressureSensor) Type() string {
|
|
|
|
return cGoUnpackString(C.QPressureSensor_QPressureSensor_Type())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QProximityFilter struct {
|
|
|
|
QSensorFilter
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QProximityFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QProximityFilter_PTR() *QProximityFilter
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityFilter) QProximityFilter_PTR() *QProximityFilter {
|
|
|
|
return ptr
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQProximityFilter(ptr QProximityFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QProximityFilter_PTR().Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQProximityFilterFromPointer(ptr unsafe.Pointer) *QProximityFilter {
|
|
|
|
var n = new(QProximityFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityFilter) DestroyQProximityFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQProximityFilter_Filter
|
|
|
|
func callbackQProximityFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QProximityReading) bool)(NewQProximityReadingFromPointer(reading)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityFilter) ConnectFilter(f func(reading *QProximityReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QProximityReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QProximityReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityFilter) DisconnectFilter() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityFilter) Filter(reading QProximityReading_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QProximityFilter_Filter(ptr.Pointer(), PointerFromQProximityReading(reading)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QProximityReading struct {
|
|
|
|
QSensorReading
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QProximityReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QProximityReading_PTR() *QProximityReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityReading) QProximityReading_PTR() *QProximityReading {
|
|
|
|
return ptr
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQProximityReading(ptr QProximityReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QProximityReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQProximityReadingFromPointer(ptr unsafe.Pointer) *QProximityReading {
|
|
|
|
var n = new(QProximityReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityReading) DestroyQProximityReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityReading) SetClose(close bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QProximityReading_SetClose(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(close))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximityReading) Close() bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QProximityReading_Close(ptr.Pointer()) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QProximitySensor struct {
|
|
|
|
QSensor
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QProximitySensor_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QProximitySensor_PTR() *QProximitySensor
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximitySensor) QProximitySensor_PTR() *QProximitySensor {
|
|
|
|
return ptr
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximitySensor) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximitySensor) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQProximitySensor(ptr QProximitySensor_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QProximitySensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQProximitySensorFromPointer(ptr unsafe.Pointer) *QProximitySensor {
|
|
|
|
var n = new(QProximitySensor)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQProximitySensor(parent core.QObject_ITF) *QProximitySensor {
|
|
|
|
var tmpValue = NewQProximitySensorFromPointer(C.QProximitySensor_NewQProximitySensor(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQProximitySensor_DestroyQProximitySensor
|
|
|
|
func callbackQProximitySensor_DestroyQProximitySensor(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QProximitySensor"); signal != nil {
|
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQProximitySensorFromPointer(ptr).DestroyQProximitySensorDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximitySensor) ConnectDestroyQProximitySensor(f func()) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QProximitySensor"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QProximitySensor", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QProximitySensor", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximitySensor) DisconnectDestroyQProximitySensor() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QProximitySensor")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximitySensor) DestroyQProximitySensor() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QProximitySensor_DestroyQProximitySensor(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximitySensor) DestroyQProximitySensorDefault() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QProximitySensor_DestroyQProximitySensorDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximitySensor) Reading() *QProximityReading {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQProximityReadingFromPointer(C.QProximitySensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QProximitySensor_Type() string {
|
|
|
|
return cGoUnpackString(C.QProximitySensor_QProximitySensor_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QProximitySensor) Type() string {
|
|
|
|
return cGoUnpackString(C.QProximitySensor_QProximitySensor_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QRotationFilter struct {
|
|
|
|
QSensorFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QRotationFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QRotationFilter_PTR() *QRotationFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationFilter) QRotationFilter_PTR() *QRotationFilter {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQRotationFilter(ptr QRotationFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QRotationFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQRotationFilterFromPointer(ptr unsafe.Pointer) *QRotationFilter {
|
|
|
|
var n = new(QRotationFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationFilter) DestroyQRotationFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
2016-08-26 20:43:21 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-04-30 20:03:25 +03:00
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQRotationFilter_Filter
|
|
|
|
func callbackQRotationFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QRotationReading) bool)(NewQRotationReadingFromPointer(reading)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationFilter) ConnectFilter(f func(reading *QRotationReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QRotationReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QRotationReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationFilter) Filter(reading QRotationReading_ITF) bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QRotationFilter_Filter(ptr.Pointer(), PointerFromQRotationReading(reading)) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QRotationReading struct {
|
|
|
|
QSensorReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QRotationReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QRotationReading_PTR() *QRotationReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationReading) QRotationReading_PTR() *QRotationReading {
|
|
|
|
return ptr
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQRotationReading(ptr QRotationReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QRotationReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQRotationReadingFromPointer(ptr unsafe.Pointer) *QRotationReading {
|
|
|
|
var n = new(QRotationReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationReading) DestroyQRotationReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationReading) SetFromEuler(x float64, y float64, z float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QRotationReading_SetFromEuler(ptr.Pointer(), C.double(x), C.double(y), C.double(z))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationReading) X() float64 {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QRotationReading_X(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationReading) Y() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QRotationReading_Y(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationReading) Z() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QRotationReading_Z(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QRotationSensor struct {
|
2016-04-28 20:43:44 +03:00
|
|
|
QSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QRotationSensor_ITF interface {
|
2016-04-28 20:43:44 +03:00
|
|
|
QSensor_ITF
|
2017-02-15 19:48:35 +03:00
|
|
|
QRotationSensor_PTR() *QRotationSensor
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) QRotationSensor_PTR() *QRotationSensor {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQRotationSensor(ptr QRotationSensor_ITF) unsafe.Pointer {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QRotationSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQRotationSensorFromPointer(ptr unsafe.Pointer) *QRotationSensor {
|
|
|
|
var n = new(QRotationSensor)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQRotationSensor(parent core.QObject_ITF) *QRotationSensor {
|
|
|
|
var tmpValue = NewQRotationSensorFromPointer(C.QRotationSensor_NewQRotationSensor(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQRotationSensor_HasZChanged
|
|
|
|
func callbackQRotationSensor_HasZChanged(ptr unsafe.Pointer, hasZ C.char) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hasZChanged"); signal != nil {
|
|
|
|
signal.(func(bool))(int8(hasZ) != 0)
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) ConnectHasZChanged(f func(hasZ bool)) {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "hasZChanged") {
|
|
|
|
C.QRotationSensor_ConnectHasZChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hasZChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasZChanged", func(hasZ bool) {
|
|
|
|
signal.(func(bool))(hasZ)
|
|
|
|
f(hasZ)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasZChanged", f)
|
|
|
|
}
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) DisconnectHasZChanged() {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QRotationSensor_DisconnectHasZChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hasZChanged")
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) HasZChanged(hasZ bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QRotationSensor_HasZChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(hasZ))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) SetHasZ(hasZ bool) {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QRotationSensor_SetHasZ(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(hasZ))))
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQRotationSensor_DestroyQRotationSensor
|
|
|
|
func callbackQRotationSensor_DestroyQRotationSensor(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QRotationSensor"); signal != nil {
|
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQRotationSensorFromPointer(ptr).DestroyQRotationSensorDefault()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) ConnectDestroyQRotationSensor(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-01-27 22:22:58 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QRotationSensor"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QRotationSensor", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QRotationSensor", f)
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) DisconnectDestroyQRotationSensor() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QRotationSensor")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) DestroyQRotationSensor() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QRotationSensor_DestroyQRotationSensor(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) DestroyQRotationSensorDefault() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QRotationSensor_DestroyQRotationSensorDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) Reading() *QRotationReading {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQRotationReadingFromPointer(C.QRotationSensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) HasZ() bool {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QRotationSensor_HasZ(ptr.Pointer()) != 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QRotationSensor_Type() string {
|
|
|
|
return cGoUnpackString(C.QRotationSensor_QRotationSensor_Type())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QRotationSensor) Type() string {
|
|
|
|
return cGoUnpackString(C.QRotationSensor_QRotationSensor_Type())
|
|
|
|
}
|
|
|
|
|
|
|
|
type QSensor struct {
|
|
|
|
core.QObject
|
|
|
|
}
|
|
|
|
|
|
|
|
type QSensor_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
QSensor_PTR() *QSensor
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSensor) QSensor_PTR() *QSensor {
|
|
|
|
return ptr
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSensor) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QObject_PTR().Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQSensor(ptr QSensor_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorFromPointer(ptr unsafe.Pointer) *QSensor {
|
|
|
|
var n = new(QSensor)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//go:generate stringer -type=QSensor__AxesOrientationMode
|
|
|
|
//QSensor::AxesOrientationMode
|
|
|
|
type QSensor__AxesOrientationMode int64
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
const (
|
|
|
|
QSensor__FixedOrientation QSensor__AxesOrientationMode = QSensor__AxesOrientationMode(0)
|
|
|
|
QSensor__AutomaticOrientation QSensor__AxesOrientationMode = QSensor__AxesOrientationMode(1)
|
|
|
|
QSensor__UserOrientation QSensor__AxesOrientationMode = QSensor__AxesOrientationMode(2)
|
|
|
|
)
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//go:generate stringer -type=QSensor__Feature
|
|
|
|
//QSensor::Feature
|
|
|
|
type QSensor__Feature int64
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
const (
|
|
|
|
QSensor__Buffering QSensor__Feature = QSensor__Feature(0)
|
|
|
|
QSensor__AlwaysOn QSensor__Feature = QSensor__Feature(1)
|
|
|
|
QSensor__GeoValues QSensor__Feature = QSensor__Feature(2)
|
|
|
|
QSensor__FieldOfView QSensor__Feature = QSensor__Feature(3)
|
|
|
|
QSensor__AccelerationMode QSensor__Feature = QSensor__Feature(4)
|
|
|
|
QSensor__SkipDuplicates QSensor__Feature = QSensor__Feature(5)
|
|
|
|
QSensor__AxesOrientation QSensor__Feature = QSensor__Feature(6)
|
|
|
|
QSensor__PressureSensorTemperature QSensor__Feature = QSensor__Feature(7)
|
|
|
|
QSensor__Reserved QSensor__Feature = QSensor__Feature(257)
|
|
|
|
)
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QSensor_DefaultSensorForType(ty core.QByteArray_ITF) *core.QByteArray {
|
|
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSensor_QSensor_DefaultSensorForType(core.PointerFromQByteArray(ty)))
|
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DefaultSensorForType(ty core.QByteArray_ITF) *core.QByteArray {
|
|
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSensor_QSensor_DefaultSensorForType(core.PointerFromQByteArray(ty)))
|
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
|
|
return tmpValue
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QSensor_SensorTypes() []*core.QByteArray {
|
|
|
|
return func(l C.struct_QtSensors_PackedList) []*core.QByteArray {
|
|
|
|
var out = make([]*core.QByteArray, int(l.len))
|
|
|
|
for i := 0; i < int(l.len); i++ {
|
|
|
|
out[i] = NewQSensorFromPointer(l.data).__sensorTypes_atList(i)
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}(C.QSensor_QSensor_SensorTypes())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SensorTypes() []*core.QByteArray {
|
|
|
|
return func(l C.struct_QtSensors_PackedList) []*core.QByteArray {
|
|
|
|
var out = make([]*core.QByteArray, int(l.len))
|
|
|
|
for i := 0; i < int(l.len); i++ {
|
|
|
|
out[i] = NewQSensorFromPointer(l.data).__sensorTypes_atList(i)
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}(C.QSensor_QSensor_SensorTypes())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QSensor_SensorsForType(ty core.QByteArray_ITF) []*core.QByteArray {
|
|
|
|
return func(l C.struct_QtSensors_PackedList) []*core.QByteArray {
|
|
|
|
var out = make([]*core.QByteArray, int(l.len))
|
|
|
|
for i := 0; i < int(l.len); i++ {
|
|
|
|
out[i] = NewQSensorFromPointer(l.data).__sensorsForType_atList(i)
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}(C.QSensor_QSensor_SensorsForType(core.PointerFromQByteArray(ty)))
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SensorsForType(ty core.QByteArray_ITF) []*core.QByteArray {
|
|
|
|
return func(l C.struct_QtSensors_PackedList) []*core.QByteArray {
|
|
|
|
var out = make([]*core.QByteArray, int(l.len))
|
|
|
|
for i := 0; i < int(l.len); i++ {
|
|
|
|
out[i] = NewQSensorFromPointer(l.data).__sensorsForType_atList(i)
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}(C.QSensor_QSensor_SensorsForType(core.PointerFromQByteArray(ty)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensor(ty core.QByteArray_ITF, parent core.QObject_ITF) *QSensor {
|
|
|
|
var tmpValue = NewQSensorFromPointer(C.QSensor_NewQSensor(core.PointerFromQByteArray(ty), core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectToBackend() bool {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensor_ConnectToBackend(ptr.Pointer()) != 0
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_Start
|
|
|
|
func callbackQSensor_Start(ptr unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "start"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorFromPointer(ptr).StartDefault())))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectStart(f func() bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "start"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", func() bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func() bool)()
|
2017-03-02 21:24:25 +03:00
|
|
|
return f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectStart() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "start")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) Start() bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensor_Start(ptr.Pointer()) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) StartDefault() bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensor_StartDefault(ptr.Pointer()) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_ActiveChanged
|
|
|
|
func callbackQSensor_ActiveChanged(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "activeChanged"); signal != nil {
|
|
|
|
signal.(func())()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectActiveChanged(f func()) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "activeChanged") {
|
|
|
|
C.QSensor_ConnectActiveChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activeChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeChanged", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectActiveChanged() {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DisconnectActiveChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "activeChanged")
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ActiveChanged() {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_ActiveChanged(ptr.Pointer())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) AddFilter(filter QSensorFilter_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_AddFilter(ptr.Pointer(), PointerFromQSensorFilter(filter))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_AlwaysOnChanged
|
|
|
|
func callbackQSensor_AlwaysOnChanged(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "alwaysOnChanged"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectAlwaysOnChanged(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "alwaysOnChanged") {
|
|
|
|
C.QSensor_ConnectAlwaysOnChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "alwaysOnChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "alwaysOnChanged", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "alwaysOnChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectAlwaysOnChanged() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DisconnectAlwaysOnChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "alwaysOnChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) AlwaysOnChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_AlwaysOnChanged(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_AvailableSensorsChanged
|
|
|
|
func callbackQSensor_AvailableSensorsChanged(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availableSensorsChanged"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectAvailableSensorsChanged(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "availableSensorsChanged") {
|
|
|
|
C.QSensor_ConnectAvailableSensorsChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availableSensorsChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availableSensorsChanged", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availableSensorsChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectAvailableSensorsChanged() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DisconnectAvailableSensorsChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availableSensorsChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) AvailableSensorsChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_AvailableSensorsChanged(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_AxesOrientationModeChanged
|
|
|
|
func callbackQSensor_AxesOrientationModeChanged(ptr unsafe.Pointer, axesOrientationMode C.longlong) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "axesOrientationModeChanged"); signal != nil {
|
|
|
|
signal.(func(QSensor__AxesOrientationMode))(QSensor__AxesOrientationMode(axesOrientationMode))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectAxesOrientationModeChanged(f func(axesOrientationMode QSensor__AxesOrientationMode)) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "axesOrientationModeChanged") {
|
|
|
|
C.QSensor_ConnectAxesOrientationModeChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "axesOrientationModeChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axesOrientationModeChanged", func(axesOrientationMode QSensor__AxesOrientationMode) {
|
|
|
|
signal.(func(QSensor__AxesOrientationMode))(axesOrientationMode)
|
|
|
|
f(axesOrientationMode)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axesOrientationModeChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectAxesOrientationModeChanged() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DisconnectAxesOrientationModeChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "axesOrientationModeChanged")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) AxesOrientationModeChanged(axesOrientationMode QSensor__AxesOrientationMode) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_AxesOrientationModeChanged(ptr.Pointer(), C.longlong(axesOrientationMode))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_BufferSizeChanged
|
|
|
|
func callbackQSensor_BufferSizeChanged(ptr unsafe.Pointer, bufferSize C.int) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bufferSizeChanged"); signal != nil {
|
|
|
|
signal.(func(int))(int(int32(bufferSize)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectBufferSizeChanged(f func(bufferSize int)) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "bufferSizeChanged") {
|
|
|
|
C.QSensor_ConnectBufferSizeChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bufferSizeChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferSizeChanged", func(bufferSize int) {
|
|
|
|
signal.(func(int))(bufferSize)
|
|
|
|
f(bufferSize)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferSizeChanged", f)
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectBufferSizeChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DisconnectBufferSizeChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bufferSizeChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) BufferSizeChanged(bufferSize int) {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_BufferSizeChanged(ptr.Pointer(), C.int(int32(bufferSize)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_BusyChanged
|
|
|
|
func callbackQSensor_BusyChanged(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "busyChanged"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectBusyChanged(f func()) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "busyChanged") {
|
|
|
|
C.QSensor_ConnectBusyChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "busyChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "busyChanged", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "busyChanged", f)
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectBusyChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DisconnectBusyChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "busyChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) BusyChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_BusyChanged(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_CurrentOrientationChanged
|
|
|
|
func callbackQSensor_CurrentOrientationChanged(ptr unsafe.Pointer, currentOrientation C.int) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "currentOrientationChanged"); signal != nil {
|
|
|
|
signal.(func(int))(int(int32(currentOrientation)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectCurrentOrientationChanged(f func(currentOrientation int)) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "currentOrientationChanged") {
|
|
|
|
C.QSensor_ConnectCurrentOrientationChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "currentOrientationChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentOrientationChanged", func(currentOrientation int) {
|
|
|
|
signal.(func(int))(currentOrientation)
|
|
|
|
f(currentOrientation)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentOrientationChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectCurrentOrientationChanged() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DisconnectCurrentOrientationChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "currentOrientationChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) CurrentOrientationChanged(currentOrientation int) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_CurrentOrientationChanged(ptr.Pointer(), C.int(int32(currentOrientation)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_DataRateChanged
|
|
|
|
func callbackQSensor_DataRateChanged(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "dataRateChanged"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectDataRateChanged(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "dataRateChanged") {
|
|
|
|
C.QSensor_ConnectDataRateChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "dataRateChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataRateChanged", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataRateChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectDataRateChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DisconnectDataRateChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "dataRateChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DataRateChanged() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DataRateChanged(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_EfficientBufferSizeChanged
|
|
|
|
func callbackQSensor_EfficientBufferSizeChanged(ptr unsafe.Pointer, efficientBufferSize C.int) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "efficientBufferSizeChanged"); signal != nil {
|
|
|
|
signal.(func(int))(int(int32(efficientBufferSize)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectEfficientBufferSizeChanged(f func(efficientBufferSize int)) {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "efficientBufferSizeChanged") {
|
|
|
|
C.QSensor_ConnectEfficientBufferSizeChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "efficientBufferSizeChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "efficientBufferSizeChanged", func(efficientBufferSize int) {
|
|
|
|
signal.(func(int))(efficientBufferSize)
|
|
|
|
f(efficientBufferSize)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "efficientBufferSizeChanged", f)
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectEfficientBufferSizeChanged() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor_DisconnectEfficientBufferSizeChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "efficientBufferSizeChanged")
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) EfficientBufferSizeChanged(efficientBufferSize int) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor_EfficientBufferSizeChanged(ptr.Pointer(), C.int(int32(efficientBufferSize)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_MaxBufferSizeChanged
|
|
|
|
func callbackQSensor_MaxBufferSizeChanged(ptr unsafe.Pointer, maxBufferSize C.int) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "maxBufferSizeChanged"); signal != nil {
|
|
|
|
signal.(func(int))(int(int32(maxBufferSize)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectMaxBufferSizeChanged(f func(maxBufferSize int)) {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "maxBufferSizeChanged") {
|
|
|
|
C.QSensor_ConnectMaxBufferSizeChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "maxBufferSizeChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maxBufferSizeChanged", func(maxBufferSize int) {
|
|
|
|
signal.(func(int))(maxBufferSize)
|
|
|
|
f(maxBufferSize)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maxBufferSizeChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectMaxBufferSizeChanged() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor_DisconnectMaxBufferSizeChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "maxBufferSizeChanged")
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) MaxBufferSizeChanged(maxBufferSize int) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor_MaxBufferSizeChanged(ptr.Pointer(), C.int(int32(maxBufferSize)))
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_ReadingChanged
|
|
|
|
func callbackQSensor_ReadingChanged(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "readingChanged"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectReadingChanged(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "readingChanged") {
|
|
|
|
C.QSensor_ConnectReadingChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "readingChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readingChanged", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readingChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectReadingChanged() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DisconnectReadingChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "readingChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ReadingChanged() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_ReadingChanged(ptr.Pointer())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) RemoveFilter(filter QSensorFilter_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor_RemoveFilter(ptr.Pointer(), PointerFromQSensorFilter(filter))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_SensorError
|
|
|
|
func callbackQSensor_SensorError(ptr unsafe.Pointer, error C.int) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "sensorError"); signal != nil {
|
|
|
|
signal.(func(int))(int(int32(error)))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectSensorError(f func(error int)) {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sensorError") {
|
|
|
|
C.QSensor_ConnectSensorError(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sensorError"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sensorError", func(error int) {
|
|
|
|
signal.(func(int))(error)
|
|
|
|
f(error)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sensorError", f)
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectSensorError() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor_DisconnectSensorError(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sensorError")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SensorError(error int) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor_SensorError(ptr.Pointer(), C.int(int32(error)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetActive(active bool) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor_SetActive(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(active))))
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetAlwaysOn(alwaysOn bool) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_SetAlwaysOn(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(alwaysOn))))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetAxesOrientationMode(axesOrientationMode QSensor__AxesOrientationMode) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_SetAxesOrientationMode(ptr.Pointer(), C.longlong(axesOrientationMode))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetBufferSize(bufferSize int) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_SetBufferSize(ptr.Pointer(), C.int(int32(bufferSize)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetCurrentOrientation(currentOrientation int) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_SetCurrentOrientation(ptr.Pointer(), C.int(int32(currentOrientation)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetDataRate(rate int) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor_SetDataRate(ptr.Pointer(), C.int(int32(rate)))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetEfficientBufferSize(efficientBufferSize int) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_SetEfficientBufferSize(ptr.Pointer(), C.int(int32(efficientBufferSize)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetIdentifier(identifier core.QByteArray_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_SetIdentifier(ptr.Pointer(), core.PointerFromQByteArray(identifier))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetMaxBufferSize(maxBufferSize int) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_SetMaxBufferSize(ptr.Pointer(), C.int(int32(maxBufferSize)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetOutputRange(index int) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_SetOutputRange(ptr.Pointer(), C.int(int32(index)))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetSkipDuplicates(skipDuplicates bool) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor_SetSkipDuplicates(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(skipDuplicates))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SetUserOrientation(userOrientation int) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_SetUserOrientation(ptr.Pointer(), C.int(int32(userOrientation)))
|
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_SkipDuplicatesChanged
|
|
|
|
func callbackQSensor_SkipDuplicatesChanged(ptr unsafe.Pointer, skipDuplicates C.char) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "skipDuplicatesChanged"); signal != nil {
|
|
|
|
signal.(func(bool))(int8(skipDuplicates) != 0)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectSkipDuplicatesChanged(f func(skipDuplicates bool)) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "skipDuplicatesChanged") {
|
|
|
|
C.QSensor_ConnectSkipDuplicatesChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "skipDuplicatesChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "skipDuplicatesChanged", func(skipDuplicates bool) {
|
|
|
|
signal.(func(bool))(skipDuplicates)
|
|
|
|
f(skipDuplicates)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "skipDuplicatesChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectSkipDuplicatesChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DisconnectSkipDuplicatesChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "skipDuplicatesChanged")
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SkipDuplicatesChanged(skipDuplicates bool) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_SkipDuplicatesChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(skipDuplicates))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_Stop
|
|
|
|
func callbackQSensor_Stop(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorFromPointer(ptr).StopDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectStop(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectStop() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) Stop() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_Stop(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) StopDefault() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_StopDefault(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_UserOrientationChanged
|
|
|
|
func callbackQSensor_UserOrientationChanged(ptr unsafe.Pointer, userOrientation C.int) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "userOrientationChanged"); signal != nil {
|
|
|
|
signal.(func(int))(int(int32(userOrientation)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectUserOrientationChanged(f func(userOrientation int)) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "userOrientationChanged") {
|
|
|
|
C.QSensor_ConnectUserOrientationChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "userOrientationChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "userOrientationChanged", func(userOrientation int) {
|
|
|
|
signal.(func(int))(userOrientation)
|
|
|
|
f(userOrientation)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "userOrientationChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectUserOrientationChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DisconnectUserOrientationChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "userOrientationChanged")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) UserOrientationChanged(userOrientation int) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_UserOrientationChanged(ptr.Pointer(), C.int(int32(userOrientation)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_DestroyQSensor
|
|
|
|
func callbackQSensor_DestroyQSensor(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QSensor"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-01-08 04:44:20 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorFromPointer(ptr).DestroyQSensorDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectDestroyQSensor(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QSensor"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSensor", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSensor", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectDestroyQSensor() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QSensor")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DestroyQSensor() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DestroyQSensor(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DestroyQSensorDefault() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DestroyQSensorDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) AxesOrientationMode() QSensor__AxesOrientationMode {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return QSensor__AxesOrientationMode(C.QSensor_AxesOrientationMode(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) Identifier() *core.QByteArray {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSensor_Identifier(ptr.Pointer()))
|
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) Type() *core.QByteArray {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSensor_Type(ptr.Pointer()))
|
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) Filters() []*QSensorFilter {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return func(l C.struct_QtSensors_PackedList) []*QSensorFilter {
|
|
|
|
var out = make([]*QSensorFilter, int(l.len))
|
|
|
|
for i := 0; i < int(l.len); i++ {
|
|
|
|
out[i] = NewQSensorFromPointer(l.data).__filters_atList(i)
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}(C.QSensor_Filters(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return make([]*QSensorFilter, 0)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) Reading() *QSensorReading {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQSensorReadingFromPointer(C.QSensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) Description() string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return cGoUnpackString(C.QSensor_Description(ptr.Pointer()))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return ""
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) IsActive() bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensor_IsActive(ptr.Pointer()) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) IsAlwaysOn() bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensor_IsAlwaysOn(ptr.Pointer()) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) IsBusy() bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensor_IsBusy(ptr.Pointer()) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) IsConnectedToBackend() bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensor_IsConnectedToBackend(ptr.Pointer()) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) IsFeatureSupported(feature QSensor__Feature) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return C.QSensor_IsFeatureSupported(ptr.Pointer(), C.longlong(feature)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) SkipDuplicates() bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensor_SkipDuplicates(ptr.Pointer()) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) BufferSize() int {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return int(int32(C.QSensor_BufferSize(ptr.Pointer())))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) CurrentOrientation() int {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return int(int32(C.QSensor_CurrentOrientation(ptr.Pointer())))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DataRate() int {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return int(int32(C.QSensor_DataRate(ptr.Pointer())))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) EfficientBufferSize() int {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int(int32(C.QSensor_EfficientBufferSize(ptr.Pointer())))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) Error() int {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return int(int32(C.QSensor_Error(ptr.Pointer())))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) MaxBufferSize() int {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return int(int32(C.QSensor_MaxBufferSize(ptr.Pointer())))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) OutputRange() int {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return int(int32(C.QSensor_OutputRange(ptr.Pointer())))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) UserOrientation() int {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return int(int32(C.QSensor_UserOrientation(ptr.Pointer())))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __sensorTypes_atList(i int) *core.QByteArray {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSensor___sensorTypes_atList(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __sensorTypes_setList(i core.QByteArray_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor___sensorTypes_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __sensorTypes_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensor___sensorTypes_newList(ptr.Pointer()))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __sensorsForType_atList(i int) *core.QByteArray {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSensor___sensorsForType_atList(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __sensorsForType_setList(i core.QByteArray_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor___sensorsForType_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __sensorsForType_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensor___sensorsForType_newList(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __filters_atList(i int) *QSensorFilter {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return NewQSensorFilterFromPointer(C.QSensor___filters_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __filters_setList(i QSensorFilter_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor___filters_setList(ptr.Pointer(), PointerFromQSensorFilter(i))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __filters_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensor___filters_newList(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSensor___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensor___dynamicPropertyNames_newList(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __findChildren_atList2(i int) *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensor___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __findChildren_setList2(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __findChildren_newList2() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensor___findChildren_newList2(ptr.Pointer()))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __findChildren_atList3(i int) *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensor___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __findChildren_setList3(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __findChildren_newList3() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensor___findChildren_newList3(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSensor) __findChildren_atList(i int) *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensor___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __findChildren_setList(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensor___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __findChildren_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensor___findChildren_newList(ptr.Pointer()))
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __children_atList(i int) *core.QObject {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensor___children_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __children_setList(i core.QObject_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) __children_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensor___children_newList(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQSensor_Event
|
|
|
|
func callbackQSensor_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) EventDefault(e core.QEvent_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensor_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_EventFilter
|
|
|
|
func callbackQSensor_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensor_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_ChildEvent
|
|
|
|
func callbackQSensor_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQSensorFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ChildEventDefault(event core.QChildEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_ConnectNotify
|
|
|
|
func callbackQSensor_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
|
|
|
NewQSensorFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_CustomEvent
|
|
|
|
func callbackQSensor_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQSensorFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) CustomEventDefault(event core.QEvent_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_DeleteLater
|
|
|
|
func callbackQSensor_DeleteLater(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
|
|
signal.(func())()
|
2017-02-10 20:18:44 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorFromPointer(ptr).DeleteLaterDefault()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DeleteLaterDefault() {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DeleteLaterDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_Destroyed
|
|
|
|
func callbackQSensor_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_DisconnectNotify
|
|
|
|
func callbackQSensor_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
|
|
|
NewQSensorFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_ObjectNameChanged
|
|
|
|
func callbackQSensor_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtSensors_PackedString) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_TimerEvent
|
|
|
|
func callbackQSensor_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensor_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
|
|
}
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensor_MetaObject
|
|
|
|
func callbackQSensor_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQSensorFromPointer(ptr).MetaObjectDefault())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensor) MetaObjectDefault() *core.QMetaObject {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return core.NewQMetaObjectFromPointer(C.QSensor_MetaObjectDefault(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorBackend struct {
|
|
|
|
core.QObject
|
|
|
|
}
|
|
|
|
|
|
|
|
type QSensorBackend_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
QSensorBackend_PTR() *QSensorBackend
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSensorBackend) QSensorBackend_PTR() *QSensorBackend {
|
|
|
|
return ptr
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSensorBackend) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QObject_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQSensorBackend(ptr QSensorBackend_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorBackend_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorBackendFromPointer(ptr unsafe.Pointer) *QSensorBackend {
|
|
|
|
var n = new(QSensorBackend)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) DestroyQSensorBackend() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) AddDataRate(min float64, max float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_AddDataRate(ptr.Pointer(), C.double(min), C.double(max))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) AddOutputRange(min float64, max float64, accuracy float64) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_AddOutputRange(ptr.Pointer(), C.double(min), C.double(max), C.double(accuracy))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) NewReadingAvailable() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_NewReadingAvailable(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) SensorBusy() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensorBackend_SensorBusy(ptr.Pointer())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) SensorError(error int) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_SensorError(ptr.Pointer(), C.int(int32(error)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) SensorStopped() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_SensorStopped(ptr.Pointer())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) SetDataRates(otherSensor QSensor_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_SetDataRates(ptr.Pointer(), PointerFromQSensor(otherSensor))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) SetDescription(description string) {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var descriptionC *C.char
|
|
|
|
if description != "" {
|
|
|
|
descriptionC = C.CString(description)
|
|
|
|
defer C.free(unsafe.Pointer(descriptionC))
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_SetDescription(ptr.Pointer(), descriptionC)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_Start
|
|
|
|
func callbackQSensorBackend_Start(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "start"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) ConnectStart(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "start"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) DisconnectStart() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "start")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) Start() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_Start(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_Stop
|
|
|
|
func callbackQSensorBackend_Stop(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) ConnectStop(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) DisconnectStop() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) Stop() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_Stop(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) Sensor() *QSensor {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQSensorFromPointer(C.QSensorBackend_Sensor(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) Reading() *QSensorReading {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQSensorReadingFromPointer(C.QSensorBackend_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_IsFeatureSupported
|
|
|
|
func callbackQSensorBackend_IsFeatureSupported(ptr unsafe.Pointer, feature C.longlong) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isFeatureSupported"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QSensor__Feature) bool)(QSensor__Feature(feature)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorBackendFromPointer(ptr).IsFeatureSupportedDefault(QSensor__Feature(feature)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) ConnectIsFeatureSupported(f func(feature QSensor__Feature) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isFeatureSupported"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFeatureSupported", func(feature QSensor__Feature) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(QSensor__Feature) bool)(feature)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(feature)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFeatureSupported", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) DisconnectIsFeatureSupported() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isFeatureSupported")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) IsFeatureSupported(feature QSensor__Feature) bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorBackend_IsFeatureSupported(ptr.Pointer(), C.longlong(feature)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) IsFeatureSupportedDefault(feature QSensor__Feature) bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorBackend_IsFeatureSupportedDefault(ptr.Pointer(), C.longlong(feature)) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSensorBackend___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensorBackend___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorBackend___dynamicPropertyNames_newList(ptr.Pointer()))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __findChildren_atList2(i int) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorBackend___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __findChildren_setList2(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensorBackend___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __findChildren_newList2() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorBackend___findChildren_newList2(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __findChildren_atList3(i int) *core.QObject {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorBackend___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __findChildren_setList3(i core.QObject_ITF) {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __findChildren_newList3() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorBackend___findChildren_newList3(ptr.Pointer()))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __findChildren_atList(i int) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorBackend___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __findChildren_setList(i core.QObject_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __findChildren_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorBackend___findChildren_newList(ptr.Pointer()))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __children_atList(i int) *core.QObject {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorBackend___children_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __children_setList(i core.QObject_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) __children_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorBackend___children_newList(ptr.Pointer()))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_Event
|
|
|
|
func callbackQSensorBackend_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorBackendFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) EventDefault(e core.QEvent_ITF) bool {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorBackend_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_EventFilter
|
|
|
|
func callbackQSensorBackend_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorBackendFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorBackend_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_ChildEvent
|
|
|
|
func callbackQSensorBackend_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
2016-04-30 20:03:25 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorBackendFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) ChildEventDefault(event core.QChildEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_ConnectNotify
|
|
|
|
func callbackQSensorBackend_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
|
|
|
NewQSensorBackendFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_CustomEvent
|
|
|
|
func callbackQSensorBackend_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQSensorBackendFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) CustomEventDefault(event core.QEvent_ITF) {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_DeleteLater
|
|
|
|
func callbackQSensorBackend_DeleteLater(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQSensorBackendFromPointer(ptr).DeleteLaterDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) DeleteLaterDefault() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_DeleteLaterDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_Destroyed
|
|
|
|
func callbackQSensorBackend_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_DisconnectNotify
|
|
|
|
func callbackQSensorBackend_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
|
|
|
NewQSensorBackendFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_ObjectNameChanged
|
|
|
|
func callbackQSensorBackend_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtSensors_PackedString) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_TimerEvent
|
|
|
|
func callbackQSensorBackend_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQSensorBackendFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorBackend_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackend_MetaObject
|
|
|
|
func callbackQSensorBackend_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQSensorBackendFromPointer(ptr).MetaObjectDefault())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackend) MetaObjectDefault() *core.QMetaObject {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return core.NewQMetaObjectFromPointer(C.QSensorBackend_MetaObjectDefault(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorBackendFactory struct {
|
|
|
|
ptr unsafe.Pointer
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorBackendFactory_ITF interface {
|
|
|
|
QSensorBackendFactory_PTR() *QSensorBackendFactory
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackendFactory) QSensorBackendFactory_PTR() *QSensorBackendFactory {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackendFactory) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackendFactory) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQSensorBackendFactory(ptr QSensorBackendFactory_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorBackendFactory_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorBackendFactoryFromPointer(ptr unsafe.Pointer) *QSensorBackendFactory {
|
|
|
|
var n = new(QSensorBackendFactory)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackendFactory) DestroyQSensorBackendFactory() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorBackendFactory_CreateBackend
|
|
|
|
func callbackQSensorBackendFactory_CreateBackend(ptr unsafe.Pointer, sensor unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "createBackend"); signal != nil {
|
|
|
|
return PointerFromQSensorBackend(signal.(func(*QSensor) *QSensorBackend)(NewQSensorFromPointer(sensor)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return PointerFromQSensorBackend(nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackendFactory) ConnectCreateBackend(f func(sensor *QSensor) *QSensorBackend) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "createBackend"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createBackend", func(sensor *QSensor) *QSensorBackend {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QSensor) *QSensorBackend)(sensor)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(sensor)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createBackend", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackendFactory) DisconnectCreateBackend() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "createBackend")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorBackendFactory) CreateBackend(sensor QSensor_ITF) *QSensorBackend {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQSensorBackendFromPointer(C.QSensorBackendFactory_CreateBackend(ptr.Pointer(), PointerFromQSensor(sensor)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorChangesInterface struct {
|
|
|
|
ptr unsafe.Pointer
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorChangesInterface_ITF interface {
|
|
|
|
QSensorChangesInterface_PTR() *QSensorChangesInterface
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorChangesInterface) QSensorChangesInterface_PTR() *QSensorChangesInterface {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorChangesInterface) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorChangesInterface) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQSensorChangesInterface(ptr QSensorChangesInterface_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorChangesInterface_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorChangesInterfaceFromPointer(ptr unsafe.Pointer) *QSensorChangesInterface {
|
|
|
|
var n = new(QSensorChangesInterface)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSensorChangesInterface) DestroyQSensorChangesInterface() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
2016-08-26 20:43:21 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-04-30 20:03:25 +03:00
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorChangesInterface_SensorsChanged
|
|
|
|
func callbackQSensorChangesInterface_SensorsChanged(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "sensorsChanged"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorChangesInterface) ConnectSensorsChanged(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sensorsChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sensorsChanged", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sensorsChanged", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorChangesInterface) DisconnectSensorsChanged() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sensorsChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorChangesInterface) SensorsChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorChangesInterface_SensorsChanged(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorFilter struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QSensorFilter_ITF interface {
|
|
|
|
QSensorFilter_PTR() *QSensorFilter
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSensorFilter) QSensorFilter_PTR() *QSensorFilter {
|
|
|
|
return ptr
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSensorFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQSensorFilter(ptr QSensorFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQSensorFilterFromPointer(ptr unsafe.Pointer) *QSensorFilter {
|
|
|
|
var n = new(QSensorFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorFilter_Filter
|
|
|
|
func callbackQSensorFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QSensorReading) bool)(NewQSensorReadingFromPointer(reading)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorFilter) ConnectFilter(f func(reading *QSensorReading) bool) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-01-26 19:58:25 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QSensorReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QSensorReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorFilter) Filter(reading QSensorReading_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorFilter_Filter(ptr.Pointer(), PointerFromQSensorReading(reading)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorFilter_DestroyQSensorFilter
|
|
|
|
func callbackQSensorFilter_DestroyQSensorFilter(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QSensorFilter"); signal != nil {
|
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQSensorFilterFromPointer(ptr).DestroyQSensorFilterDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSensorFilter) ConnectDestroyQSensorFilter(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QSensorFilter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSensorFilter", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSensorFilter", f)
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorFilter) DisconnectDestroyQSensorFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QSensorFilter")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorFilter) DestroyQSensorFilter() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorFilter_DestroyQSensorFilter(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorFilter) DestroyQSensorFilterDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensorFilter_DestroyQSensorFilterDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorFilter) M_sensor() *QSensor {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQSensorFromPointer(C.QSensorFilter_M_sensor(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorFilter) SetM_sensor(vqs QSensor_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorFilter_SetM_sensor(ptr.Pointer(), PointerFromQSensor(vqs))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorGesture struct {
|
|
|
|
core.QObject
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorGesture_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
QSensorGesture_PTR() *QSensorGesture
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) QSensorGesture_PTR() *QSensorGesture {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QObject_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQSensorGesture(ptr QSensorGesture_ITF) unsafe.Pointer {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QSensorGesture_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorGestureFromPointer(ptr unsafe.Pointer) *QSensorGesture {
|
|
|
|
var n = new(QSensorGesture)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorGesture(ids []string, parent core.QObject_ITF) *QSensorGesture {
|
|
|
|
var idsC = C.CString(strings.Join(ids, "|"))
|
|
|
|
defer C.free(unsafe.Pointer(idsC))
|
|
|
|
var tmpValue = NewQSensorGestureFromPointer(C.QSensorGesture_NewQSensorGesture(idsC, core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) IsActive() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return C.QSensorGesture_IsActive(ptr.Pointer()) != 0
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesture_Detected
|
|
|
|
func callbackQSensorGesture_Detected(ptr unsafe.Pointer, gestureId C.struct_QtSensors_PackedString) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "detected"); signal != nil {
|
|
|
|
signal.(func(string))(cGoUnpackString(gestureId))
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) ConnectDetected(f func(gestureId string)) {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "detected") {
|
|
|
|
C.QSensorGesture_ConnectDetected(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "detected"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "detected", func(gestureId string) {
|
|
|
|
signal.(func(string))(gestureId)
|
|
|
|
f(gestureId)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "detected", f)
|
|
|
|
}
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) DisconnectDetected() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture_DisconnectDetected(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "detected")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) Detected(gestureId string) {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var gestureIdC *C.char
|
|
|
|
if gestureId != "" {
|
|
|
|
gestureIdC = C.CString(gestureId)
|
|
|
|
defer C.free(unsafe.Pointer(gestureIdC))
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture_Detected(ptr.Pointer(), gestureIdC)
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) StartDetection() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture_StartDetection(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) StopDetection() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensorGesture_StopDetection(ptr.Pointer())
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) DestroyQSensorGesture() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensorGesture_DestroyQSensorGesture(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) GestureSignals() []string {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return strings.Split(cGoUnpackString(C.QSensorGesture_GestureSignals(ptr.Pointer())), "|")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return make([]string, 0)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) InvalidIds() []string {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return strings.Split(cGoUnpackString(C.QSensorGesture_InvalidIds(ptr.Pointer())), "|")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return make([]string, 0)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) ValidIds() []string {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return strings.Split(cGoUnpackString(C.QSensorGesture_ValidIds(ptr.Pointer())), "|")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return make([]string, 0)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSensorGesture___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-01-27 22:22:58 +03:00
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGesture___dynamicPropertyNames_newList(ptr.Pointer()))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __findChildren_atList2(i int) *core.QObject {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorGesture___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __findChildren_setList2(i core.QObject_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __findChildren_newList2() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGesture___findChildren_newList2(ptr.Pointer()))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __findChildren_atList3(i int) *core.QObject {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorGesture___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __findChildren_setList3(i core.QObject_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __findChildren_newList3() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGesture___findChildren_newList3(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __findChildren_atList(i int) *core.QObject {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorGesture___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __findChildren_setList(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensorGesture___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __findChildren_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGesture___findChildren_newList(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __children_atList(i int) *core.QObject {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorGesture___children_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __children_setList(i core.QObject_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) __children_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGesture___children_newList(ptr.Pointer()))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesture_Event
|
|
|
|
func callbackQSensorGesture_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorGestureFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) EventDefault(e core.QEvent_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorGesture_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesture_EventFilter
|
|
|
|
func callbackQSensorGesture_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorGestureFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorGesture_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesture_ChildEvent
|
|
|
|
func callbackQSensorGesture_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQSensorGestureFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) ChildEventDefault(event core.QChildEvent_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesture_ConnectNotify
|
|
|
|
func callbackQSensorGesture_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
|
|
|
NewQSensorGestureFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesture_CustomEvent
|
|
|
|
func callbackQSensorGesture_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorGestureFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) CustomEventDefault(event core.QEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesture_DeleteLater
|
|
|
|
func callbackQSensorGesture_DeleteLater(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQSensorGestureFromPointer(ptr).DeleteLaterDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) DeleteLaterDefault() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture_DeleteLaterDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesture_Destroyed
|
|
|
|
func callbackQSensorGesture_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesture_DisconnectNotify
|
|
|
|
func callbackQSensorGesture_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorGestureFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesture_ObjectNameChanged
|
|
|
|
func callbackQSensorGesture_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtSensors_PackedString) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesture_TimerEvent
|
|
|
|
func callbackQSensorGesture_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorGestureFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesture_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesture_MetaObject
|
|
|
|
func callbackQSensorGesture_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return core.PointerFromQMetaObject(NewQSensorGestureFromPointer(ptr).MetaObjectDefault())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesture) MetaObjectDefault() *core.QMetaObject {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return core.NewQMetaObjectFromPointer(C.QSensorGesture_MetaObjectDefault(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorGestureManager struct {
|
|
|
|
core.QObject
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorGestureManager_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
QSensorGestureManager_PTR() *QSensorGestureManager
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) QSensorGestureManager_PTR() *QSensorGestureManager {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QObject_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQSensorGestureManager(ptr QSensorGestureManager_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorGestureManager_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorGestureManagerFromPointer(ptr unsafe.Pointer) *QSensorGestureManager {
|
|
|
|
var n = new(QSensorGestureManager)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
func NewQSensorGestureManager(parent core.QObject_ITF) *QSensorGestureManager {
|
|
|
|
var tmpValue = NewQSensorGestureManagerFromPointer(C.QSensorGestureManager_NewQSensorGestureManager(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QSensorGestureManager_SensorGestureRecognizer(id string) *QSensorGestureRecognizer {
|
2017-02-21 16:13:05 +03:00
|
|
|
var idC *C.char
|
|
|
|
if id != "" {
|
|
|
|
idC = C.CString(id)
|
|
|
|
defer C.free(unsafe.Pointer(idC))
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQSensorGestureRecognizerFromPointer(C.QSensorGestureManager_QSensorGestureManager_SensorGestureRecognizer(idC))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) SensorGestureRecognizer(id string) *QSensorGestureRecognizer {
|
2017-02-21 16:13:05 +03:00
|
|
|
var idC *C.char
|
|
|
|
if id != "" {
|
|
|
|
idC = C.CString(id)
|
|
|
|
defer C.free(unsafe.Pointer(idC))
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQSensorGestureRecognizerFromPointer(C.QSensorGestureManager_QSensorGestureManager_SensorGestureRecognizer(idC))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) RegisterSensorGestureRecognizer(recognizer QSensorGestureRecognizer_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorGestureManager_RegisterSensorGestureRecognizer(ptr.Pointer(), PointerFromQSensorGestureRecognizer(recognizer)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureManager_NewSensorGestureAvailable
|
|
|
|
func callbackQSensorGestureManager_NewSensorGestureAvailable(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "newSensorGestureAvailable"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) ConnectNewSensorGestureAvailable(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "newSensorGestureAvailable") {
|
|
|
|
C.QSensorGestureManager_ConnectNewSensorGestureAvailable(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "newSensorGestureAvailable"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newSensorGestureAvailable", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newSensorGestureAvailable", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) DisconnectNewSensorGestureAvailable() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager_DisconnectNewSensorGestureAvailable(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "newSensorGestureAvailable")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) NewSensorGestureAvailable() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager_NewSensorGestureAvailable(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) DestroyQSensorGestureManager() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSensorGestureManager_DestroyQSensorGestureManager(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) GestureIds() []string {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return strings.Split(cGoUnpackString(C.QSensorGestureManager_GestureIds(ptr.Pointer())), "|")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return make([]string, 0)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) RecognizerSignals(gestureId string) []string {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var gestureIdC *C.char
|
|
|
|
if gestureId != "" {
|
|
|
|
gestureIdC = C.CString(gestureId)
|
|
|
|
defer C.free(unsafe.Pointer(gestureIdC))
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return strings.Split(cGoUnpackString(C.QSensorGestureManager_RecognizerSignals(ptr.Pointer(), gestureIdC)), "|")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return make([]string, 0)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSensorGestureManager___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGestureManager___dynamicPropertyNames_newList(ptr.Pointer()))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __findChildren_atList2(i int) *core.QObject {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorGestureManager___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-01-27 22:22:58 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __findChildren_setList2(i core.QObject_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __findChildren_newList2() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGestureManager___findChildren_newList2(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __findChildren_atList3(i int) *core.QObject {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorGestureManager___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-01-27 22:22:58 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __findChildren_setList3(i core.QObject_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __findChildren_newList3() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGestureManager___findChildren_newList3(ptr.Pointer()))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __findChildren_atList(i int) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorGestureManager___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-01-27 22:22:58 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __findChildren_setList(i core.QObject_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __findChildren_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGestureManager___findChildren_newList(ptr.Pointer()))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __children_atList(i int) *core.QObject {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorGestureManager___children_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __children_setList(i core.QObject_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) __children_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGestureManager___children_newList(ptr.Pointer()))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureManager_Event
|
|
|
|
func callbackQSensorGestureManager_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorGestureManagerFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) EventDefault(e core.QEvent_ITF) bool {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorGestureManager_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureManager_EventFilter
|
|
|
|
func callbackQSensorGestureManager_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorGestureManagerFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorGestureManager_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return false
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureManager_ChildEvent
|
|
|
|
func callbackQSensorGestureManager_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQSensorGestureManagerFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) ChildEventDefault(event core.QChildEvent_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
|
|
}
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureManager_ConnectNotify
|
|
|
|
func callbackQSensorGestureManager_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
|
|
|
NewQSensorGestureManagerFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureManager_CustomEvent
|
|
|
|
func callbackQSensorGestureManager_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQSensorGestureManagerFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) CustomEventDefault(event core.QEvent_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureManager_DeleteLater
|
|
|
|
func callbackQSensorGestureManager_DeleteLater(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
|
|
signal.(func())()
|
2017-01-27 22:22:58 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorGestureManagerFromPointer(ptr).DeleteLaterDefault()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) DeleteLaterDefault() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager_DeleteLaterDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureManager_Destroyed
|
|
|
|
func callbackQSensorGestureManager_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureManager_DisconnectNotify
|
|
|
|
func callbackQSensorGestureManager_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
|
|
|
NewQSensorGestureManagerFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureManager_ObjectNameChanged
|
|
|
|
func callbackQSensorGestureManager_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtSensors_PackedString) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureManager_TimerEvent
|
|
|
|
func callbackQSensorGestureManager_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
2017-01-27 22:22:58 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorGestureManagerFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureManager_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureManager_MetaObject
|
|
|
|
func callbackQSensorGestureManager_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQSensorGestureManagerFromPointer(ptr).MetaObjectDefault())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureManager) MetaObjectDefault() *core.QMetaObject {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return core.NewQMetaObjectFromPointer(C.QSensorGestureManager_MetaObjectDefault(ptr.Pointer()))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorGesturePluginInterface struct {
|
|
|
|
ptr unsafe.Pointer
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorGesturePluginInterface_ITF interface {
|
|
|
|
QSensorGesturePluginInterface_PTR() *QSensorGesturePluginInterface
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) QSensorGesturePluginInterface_PTR() *QSensorGesturePluginInterface {
|
|
|
|
return ptr
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQSensorGesturePluginInterface(ptr QSensorGesturePluginInterface_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorGesturePluginInterface_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorGesturePluginInterfaceFromPointer(ptr unsafe.Pointer) *QSensorGesturePluginInterface {
|
|
|
|
var n = new(QSensorGesturePluginInterface)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesturePluginInterface_CreateRecognizers
|
|
|
|
func callbackQSensorGesturePluginInterface_CreateRecognizers(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "createRecognizers"); signal != nil {
|
|
|
|
return func() unsafe.Pointer {
|
|
|
|
var tmpList = NewQSensorGesturePluginInterfaceFromPointer(NewQSensorGesturePluginInterfaceFromPointer(nil).__createRecognizers_newList())
|
|
|
|
for _, v := range signal.(func() []*QSensorGestureRecognizer)() {
|
|
|
|
tmpList.__createRecognizers_setList(v)
|
|
|
|
}
|
|
|
|
return tmpList.Pointer()
|
|
|
|
}()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return func() unsafe.Pointer {
|
|
|
|
var tmpList = NewQSensorGesturePluginInterfaceFromPointer(NewQSensorGesturePluginInterfaceFromPointer(nil).__createRecognizers_newList())
|
|
|
|
for _, v := range make([]*QSensorGestureRecognizer, 0) {
|
|
|
|
tmpList.__createRecognizers_setList(v)
|
|
|
|
}
|
|
|
|
return tmpList.Pointer()
|
|
|
|
}()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) ConnectCreateRecognizers(f func() []*QSensorGestureRecognizer) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "createRecognizers"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createRecognizers", func() []*QSensorGestureRecognizer {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func() []*QSensorGestureRecognizer)()
|
2017-03-02 21:24:25 +03:00
|
|
|
return f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createRecognizers", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) DisconnectCreateRecognizers() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "createRecognizers")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) CreateRecognizers() []*QSensorGestureRecognizer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return func(l C.struct_QtSensors_PackedList) []*QSensorGestureRecognizer {
|
|
|
|
var out = make([]*QSensorGestureRecognizer, int(l.len))
|
|
|
|
for i := 0; i < int(l.len); i++ {
|
|
|
|
out[i] = NewQSensorGesturePluginInterfaceFromPointer(l.data).__createRecognizers_atList(i)
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}(C.QSensorGesturePluginInterface_CreateRecognizers(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return make([]*QSensorGestureRecognizer, 0)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorGesturePluginInterface() *QSensorGesturePluginInterface {
|
|
|
|
return NewQSensorGesturePluginInterfaceFromPointer(C.QSensorGesturePluginInterface_NewQSensorGesturePluginInterface())
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesturePluginInterface_DestroyQSensorGesturePluginInterface
|
|
|
|
func callbackQSensorGesturePluginInterface_DestroyQSensorGesturePluginInterface(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QSensorGesturePluginInterface"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorGesturePluginInterfaceFromPointer(ptr).DestroyQSensorGesturePluginInterfaceDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) ConnectDestroyQSensorGesturePluginInterface(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QSensorGesturePluginInterface"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSensorGesturePluginInterface", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSensorGesturePluginInterface", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) DisconnectDestroyQSensorGesturePluginInterface() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QSensorGesturePluginInterface")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) DestroyQSensorGesturePluginInterface() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesturePluginInterface_DestroyQSensorGesturePluginInterface(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) DestroyQSensorGesturePluginInterfaceDefault() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesturePluginInterface_DestroyQSensorGesturePluginInterfaceDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesturePluginInterface_Name
|
|
|
|
func callbackQSensorGesturePluginInterface_Name(ptr unsafe.Pointer) *C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "name"); signal != nil {
|
|
|
|
return C.CString(signal.(func() string)())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return C.CString("")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) ConnectName(f func() string) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "name"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", func() string {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func() string)()
|
2017-03-02 21:24:25 +03:00
|
|
|
return f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) DisconnectName() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "name")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) Name() string {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return cGoUnpackString(C.QSensorGesturePluginInterface_Name(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return ""
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGesturePluginInterface_SupportedIds
|
|
|
|
func callbackQSensorGesturePluginInterface_SupportedIds(ptr unsafe.Pointer) *C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedIds"); signal != nil {
|
|
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return C.CString(strings.Join(make([]string, 0), "|"))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) ConnectSupportedIds(f func() []string) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedIds"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedIds", func() []string {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func() []string)()
|
2017-03-02 21:24:25 +03:00
|
|
|
return f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedIds", f)
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) DisconnectSupportedIds() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedIds")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) SupportedIds() []string {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return strings.Split(cGoUnpackString(C.QSensorGesturePluginInterface_SupportedIds(ptr.Pointer())), "|")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return make([]string, 0)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) __createRecognizers_atList(i int) *QSensorGestureRecognizer {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQSensorGestureRecognizerFromPointer(C.QSensorGesturePluginInterface___createRecognizers_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) __createRecognizers_setList(i QSensorGestureRecognizer_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGesturePluginInterface___createRecognizers_setList(ptr.Pointer(), PointerFromQSensorGestureRecognizer(i))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGesturePluginInterface) __createRecognizers_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGesturePluginInterface___createRecognizers_newList(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorGestureRecognizer struct {
|
|
|
|
core.QObject
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorGestureRecognizer_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
QSensorGestureRecognizer_PTR() *QSensorGestureRecognizer
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSensorGestureRecognizer) QSensorGestureRecognizer_PTR() *QSensorGestureRecognizer {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QObject_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQSensorGestureRecognizer(ptr QSensorGestureRecognizer_ITF) unsafe.Pointer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QSensorGestureRecognizer_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorGestureRecognizerFromPointer(ptr unsafe.Pointer) *QSensorGestureRecognizer {
|
|
|
|
var n = new(QSensorGestureRecognizer)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2016-01-26 19:58:25 +03:00
|
|
|
return n
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorGestureRecognizer(parent core.QObject_ITF) *QSensorGestureRecognizer {
|
|
|
|
var tmpValue = NewQSensorGestureRecognizerFromPointer(C.QSensorGestureRecognizer_NewQSensorGestureRecognizer(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_IsActive
|
|
|
|
func callbackQSensorGestureRecognizer_IsActive(ptr unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isActive"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) ConnectIsActive(f func() bool) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isActive"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isActive", func() bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func() bool)()
|
2017-03-02 21:24:25 +03:00
|
|
|
return f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isActive", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) DisconnectIsActive() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isActive")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) IsActive() bool {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorGestureRecognizer_IsActive(ptr.Pointer()) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_Start
|
|
|
|
func callbackQSensorGestureRecognizer_Start(ptr unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "start"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) ConnectStart(f func() bool) {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "start"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", func() bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func() bool)()
|
2017-03-02 21:24:25 +03:00
|
|
|
return f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) DisconnectStart() {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "start")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) Start() bool {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorGestureRecognizer_Start(ptr.Pointer()) != 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return false
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_Stop
|
|
|
|
func callbackQSensorGestureRecognizer_Stop(ptr unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) ConnectStop(f func() bool) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func() bool)()
|
2017-03-02 21:24:25 +03:00
|
|
|
return f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) DisconnectStop() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) Stop() bool {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorGestureRecognizer_Stop(ptr.Pointer()) != 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_Create
|
|
|
|
func callbackQSensorGestureRecognizer_Create(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "create"); signal != nil {
|
|
|
|
signal.(func())()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) ConnectCreate(f func()) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "create"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "create", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "create", f)
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) DisconnectCreate() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "create")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) Create() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_Create(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) CreateBackend() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_CreateBackend(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_Detected
|
|
|
|
func callbackQSensorGestureRecognizer_Detected(ptr unsafe.Pointer, gestureId C.struct_QtSensors_PackedString) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "detected"); signal != nil {
|
|
|
|
signal.(func(string))(cGoUnpackString(gestureId))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) ConnectDetected(f func(gestureId string)) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "detected") {
|
|
|
|
C.QSensorGestureRecognizer_ConnectDetected(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "detected"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "detected", func(gestureId string) {
|
|
|
|
signal.(func(string))(gestureId)
|
|
|
|
f(gestureId)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "detected", f)
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) DisconnectDetected() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_DisconnectDetected(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "detected")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) Detected(gestureId string) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var gestureIdC *C.char
|
|
|
|
if gestureId != "" {
|
|
|
|
gestureIdC = C.CString(gestureId)
|
|
|
|
defer C.free(unsafe.Pointer(gestureIdC))
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_Detected(ptr.Pointer(), gestureIdC)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) StartBackend() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_StartBackend(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) StopBackend() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_StopBackend(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_DestroyQSensorGestureRecognizer
|
|
|
|
func callbackQSensorGestureRecognizer_DestroyQSensorGestureRecognizer(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QSensorGestureRecognizer"); signal != nil {
|
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQSensorGestureRecognizerFromPointer(ptr).DestroyQSensorGestureRecognizerDefault()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) ConnectDestroyQSensorGestureRecognizer(f func()) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QSensorGestureRecognizer"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSensorGestureRecognizer", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSensorGestureRecognizer", f)
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) DisconnectDestroyQSensorGestureRecognizer() {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QSensorGestureRecognizer")
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) DestroyQSensorGestureRecognizer() {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_DestroyQSensorGestureRecognizer(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) DestroyQSensorGestureRecognizerDefault() {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_DestroyQSensorGestureRecognizerDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_Id
|
|
|
|
func callbackQSensorGestureRecognizer_Id(ptr unsafe.Pointer) *C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "id"); signal != nil {
|
|
|
|
return C.CString(signal.(func() string)())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.CString("")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) ConnectId(f func() string) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "id"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "id", func() string {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func() string)()
|
2017-03-02 21:24:25 +03:00
|
|
|
return f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "id", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) DisconnectId() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "id")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) Id() string {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return cGoUnpackString(C.QSensorGestureRecognizer_Id(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return ""
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) GestureSignals() []string {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return strings.Split(cGoUnpackString(C.QSensorGestureRecognizer_GestureSignals(ptr.Pointer())), "|")
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return make([]string, 0)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSensorGestureRecognizer___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGestureRecognizer___dynamicPropertyNames_newList(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __findChildren_atList2(i int) *core.QObject {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorGestureRecognizer___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __findChildren_setList2(i core.QObject_ITF) {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __findChildren_newList2() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGestureRecognizer___findChildren_newList2(ptr.Pointer()))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __findChildren_atList3(i int) *core.QObject {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorGestureRecognizer___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __findChildren_setList3(i core.QObject_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __findChildren_newList3() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGestureRecognizer___findChildren_newList3(ptr.Pointer()))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __findChildren_atList(i int) *core.QObject {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorGestureRecognizer___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __findChildren_setList(i core.QObject_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __findChildren_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGestureRecognizer___findChildren_newList(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __children_atList(i int) *core.QObject {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorGestureRecognizer___children_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __children_setList(i core.QObject_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) __children_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorGestureRecognizer___children_newList(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_Event
|
|
|
|
func callbackQSensorGestureRecognizer_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorGestureRecognizerFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) EventDefault(e core.QEvent_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorGestureRecognizer_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_EventFilter
|
|
|
|
func callbackQSensorGestureRecognizer_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorGestureRecognizerFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorGestureRecognizer_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_ChildEvent
|
|
|
|
func callbackQSensorGestureRecognizer_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorGestureRecognizerFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) ChildEventDefault(event core.QChildEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_ConnectNotify
|
|
|
|
func callbackQSensorGestureRecognizer_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
|
|
|
NewQSensorGestureRecognizerFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_CustomEvent
|
|
|
|
func callbackQSensorGestureRecognizer_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorGestureRecognizerFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) CustomEventDefault(event core.QEvent_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_DeleteLater
|
|
|
|
func callbackQSensorGestureRecognizer_DeleteLater(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQSensorGestureRecognizerFromPointer(ptr).DeleteLaterDefault()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) DeleteLaterDefault() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_DeleteLaterDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_Destroyed
|
|
|
|
func callbackQSensorGestureRecognizer_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_DisconnectNotify
|
|
|
|
func callbackQSensorGestureRecognizer_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
2016-04-30 20:03:25 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorGestureRecognizerFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_ObjectNameChanged
|
|
|
|
func callbackQSensorGestureRecognizer_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtSensors_PackedString) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_TimerEvent
|
|
|
|
func callbackQSensorGestureRecognizer_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQSensorGestureRecognizerFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorGestureRecognizer_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorGestureRecognizer_MetaObject
|
|
|
|
func callbackQSensorGestureRecognizer_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQSensorGestureRecognizerFromPointer(ptr).MetaObjectDefault())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorGestureRecognizer) MetaObjectDefault() *core.QMetaObject {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return core.NewQMetaObjectFromPointer(C.QSensorGestureRecognizer_MetaObjectDefault(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorManager struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorManager_ITF interface {
|
|
|
|
QSensorManager_PTR() *QSensorManager
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorManager) QSensorManager_PTR() *QSensorManager {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorManager) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorManager) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQSensorManager(ptr QSensorManager_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorManager_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorManagerFromPointer(ptr unsafe.Pointer) *QSensorManager {
|
|
|
|
var n = new(QSensorManager)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorManager) DestroyQSensorManager() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QSensorManager_CreateBackend(sensor QSensor_ITF) *QSensorBackend {
|
|
|
|
var tmpValue = NewQSensorBackendFromPointer(C.QSensorManager_QSensorManager_CreateBackend(PointerFromQSensor(sensor)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorManager) CreateBackend(sensor QSensor_ITF) *QSensorBackend {
|
|
|
|
var tmpValue = NewQSensorBackendFromPointer(C.QSensorManager_QSensorManager_CreateBackend(PointerFromQSensor(sensor)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QSensorManager_IsBackendRegistered(ty core.QByteArray_ITF, identifier core.QByteArray_ITF) bool {
|
|
|
|
return C.QSensorManager_QSensorManager_IsBackendRegistered(core.PointerFromQByteArray(ty), core.PointerFromQByteArray(identifier)) != 0
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorManager) IsBackendRegistered(ty core.QByteArray_ITF, identifier core.QByteArray_ITF) bool {
|
|
|
|
return C.QSensorManager_QSensorManager_IsBackendRegistered(core.PointerFromQByteArray(ty), core.PointerFromQByteArray(identifier)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QSensorManager_RegisterBackend(ty core.QByteArray_ITF, identifier core.QByteArray_ITF, factory QSensorBackendFactory_ITF) {
|
|
|
|
C.QSensorManager_QSensorManager_RegisterBackend(core.PointerFromQByteArray(ty), core.PointerFromQByteArray(identifier), PointerFromQSensorBackendFactory(factory))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorManager) RegisterBackend(ty core.QByteArray_ITF, identifier core.QByteArray_ITF, factory QSensorBackendFactory_ITF) {
|
|
|
|
C.QSensorManager_QSensorManager_RegisterBackend(core.PointerFromQByteArray(ty), core.PointerFromQByteArray(identifier), PointerFromQSensorBackendFactory(factory))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QSensorManager_SetDefaultBackend(ty core.QByteArray_ITF, identifier core.QByteArray_ITF) {
|
|
|
|
C.QSensorManager_QSensorManager_SetDefaultBackend(core.PointerFromQByteArray(ty), core.PointerFromQByteArray(identifier))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorManager) SetDefaultBackend(ty core.QByteArray_ITF, identifier core.QByteArray_ITF) {
|
|
|
|
C.QSensorManager_QSensorManager_SetDefaultBackend(core.PointerFromQByteArray(ty), core.PointerFromQByteArray(identifier))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QSensorManager_UnregisterBackend(ty core.QByteArray_ITF, identifier core.QByteArray_ITF) {
|
|
|
|
C.QSensorManager_QSensorManager_UnregisterBackend(core.PointerFromQByteArray(ty), core.PointerFromQByteArray(identifier))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorManager) UnregisterBackend(ty core.QByteArray_ITF, identifier core.QByteArray_ITF) {
|
|
|
|
C.QSensorManager_QSensorManager_UnregisterBackend(core.PointerFromQByteArray(ty), core.PointerFromQByteArray(identifier))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorPluginInterface struct {
|
|
|
|
ptr unsafe.Pointer
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorPluginInterface_ITF interface {
|
|
|
|
QSensorPluginInterface_PTR() *QSensorPluginInterface
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorPluginInterface) QSensorPluginInterface_PTR() *QSensorPluginInterface {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorPluginInterface) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorPluginInterface) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQSensorPluginInterface(ptr QSensorPluginInterface_ITF) unsafe.Pointer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QSensorPluginInterface_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
func NewQSensorPluginInterfaceFromPointer(ptr unsafe.Pointer) *QSensorPluginInterface {
|
|
|
|
var n = new(QSensorPluginInterface)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorPluginInterface) DestroyQSensorPluginInterface() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorPluginInterface_RegisterSensors
|
|
|
|
func callbackQSensorPluginInterface_RegisterSensors(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "registerSensors"); signal != nil {
|
|
|
|
signal.(func())()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorPluginInterface) ConnectRegisterSensors(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "registerSensors"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "registerSensors", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "registerSensors", f)
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorPluginInterface) DisconnectRegisterSensors() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "registerSensors")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorPluginInterface) RegisterSensors() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorPluginInterface_RegisterSensors(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorReading struct {
|
|
|
|
core.QObject
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QSensorReading_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
QSensorReading_PTR() *QSensorReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) QSensorReading_PTR() *QSensorReading {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QObject_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQSensorReading(ptr QSensorReading_ITF) unsafe.Pointer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQSensorReadingFromPointer(ptr unsafe.Pointer) *QSensorReading {
|
|
|
|
var n = new(QSensorReading)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2016-01-26 19:58:25 +03:00
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) DestroyQSensorReading() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) SetTimestamp(timestamp uint64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorReading_SetTimestamp(ptr.Pointer(), C.ulonglong(timestamp))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) Value(index int) *core.QVariant {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQVariantFromPointer(C.QSensorReading_Value(ptr.Pointer(), C.int(int32(index))))
|
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) ValueCount() int {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return int(int32(C.QSensorReading_ValueCount(ptr.Pointer())))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) Timestamp() uint64 {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return uint64(C.QSensorReading_Timestamp(ptr.Pointer()))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSensorReading___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-01-27 22:22:58 +03:00
|
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorReading___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorReading___dynamicPropertyNames_newList(ptr.Pointer()))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __findChildren_atList2(i int) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorReading___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-01-27 22:22:58 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __findChildren_setList2(i core.QObject_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorReading___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __findChildren_newList2() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorReading___findChildren_newList2(ptr.Pointer()))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __findChildren_atList3(i int) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorReading___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-01-27 22:22:58 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __findChildren_setList3(i core.QObject_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorReading___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __findChildren_newList3() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorReading___findChildren_newList3(ptr.Pointer()))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __findChildren_atList(i int) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorReading___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-01-27 22:22:58 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __findChildren_setList(i core.QObject_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorReading___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __findChildren_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorReading___findChildren_newList(ptr.Pointer()))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __children_atList(i int) *core.QObject {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSensorReading___children_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __children_setList(i core.QObject_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorReading___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) __children_newList() unsafe.Pointer {
|
|
|
|
return unsafe.Pointer(C.QSensorReading___children_newList(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorReading_Event
|
|
|
|
func callbackQSensorReading_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorReadingFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) EventDefault(e core.QEvent_ITF) bool {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorReading_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorReading_EventFilter
|
|
|
|
func callbackQSensorReading_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSensorReadingFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QSensorReading_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorReading_ChildEvent
|
|
|
|
func callbackQSensorReading_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorReadingFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) ChildEventDefault(event core.QChildEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorReading_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorReading_ConnectNotify
|
|
|
|
func callbackQSensorReading_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorReadingFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorReading_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorReading_CustomEvent
|
|
|
|
func callbackQSensorReading_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
2016-01-08 04:44:20 +03:00
|
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorReadingFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) CustomEventDefault(event core.QEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorReading_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorReading_DeleteLater
|
|
|
|
func callbackQSensorReading_DeleteLater(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
|
|
signal.(func())()
|
2017-02-10 20:18:44 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQSensorReadingFromPointer(ptr).DeleteLaterDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) DeleteLaterDefault() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorReading_DeleteLaterDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorReading_Destroyed
|
|
|
|
func callbackQSensorReading_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorReading_DisconnectNotify
|
|
|
|
func callbackQSensorReading_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
|
|
|
NewQSensorReadingFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorReading_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorReading_ObjectNameChanged
|
|
|
|
func callbackQSensorReading_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtSensors_PackedString) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorReading_TimerEvent
|
|
|
|
func callbackQSensorReading_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQSensorReadingFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QSensorReading_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQSensorReading_MetaObject
|
|
|
|
func callbackQSensorReading_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQSensorReadingFromPointer(ptr).MetaObjectDefault())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QSensorReading) MetaObjectDefault() *core.QMetaObject {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return core.NewQMetaObjectFromPointer(C.QSensorReading_MetaObjectDefault(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QTapFilter struct {
|
|
|
|
QSensorFilter
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QTapFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QTapFilter_PTR() *QTapFilter
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapFilter) QTapFilter_PTR() *QTapFilter {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapFilter) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapFilter) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQTapFilter(ptr QTapFilter_ITF) unsafe.Pointer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QTapFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQTapFilterFromPointer(ptr unsafe.Pointer) *QTapFilter {
|
|
|
|
var n = new(QTapFilter)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapFilter) DestroyQTapFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
2016-08-26 20:43:21 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-04-28 20:43:44 +03:00
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQTapFilter_Filter
|
|
|
|
func callbackQTapFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QTapReading) bool)(NewQTapReadingFromPointer(reading)))))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-05-21 23:50:57 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-05-21 23:50:57 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapFilter) ConnectFilter(f func(reading *QTapReading) bool) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QTapReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QTapReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapFilter) DisconnectFilter() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapFilter) Filter(reading QTapReading_ITF) bool {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QTapFilter_Filter(ptr.Pointer(), PointerFromQTapReading(reading)) != 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QTapReading struct {
|
|
|
|
QSensorReading
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QTapReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QTapReading_PTR() *QTapReading
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapReading) QTapReading_PTR() *QTapReading {
|
|
|
|
return ptr
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQTapReading(ptr QTapReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QTapReading_PTR().Pointer()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQTapReadingFromPointer(ptr unsafe.Pointer) *QTapReading {
|
|
|
|
var n = new(QTapReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapReading) DestroyQTapReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//go:generate stringer -type=QTapReading__TapDirection
|
|
|
|
//QTapReading::TapDirection
|
|
|
|
type QTapReading__TapDirection int64
|
2017-01-27 22:22:58 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
const (
|
|
|
|
QTapReading__Undefined QTapReading__TapDirection = QTapReading__TapDirection(0)
|
|
|
|
QTapReading__X QTapReading__TapDirection = QTapReading__TapDirection(0x0001)
|
|
|
|
QTapReading__Y QTapReading__TapDirection = QTapReading__TapDirection(0x0002)
|
|
|
|
QTapReading__Z QTapReading__TapDirection = QTapReading__TapDirection(0x0004)
|
|
|
|
QTapReading__X_Pos QTapReading__TapDirection = QTapReading__TapDirection(0x0011)
|
|
|
|
QTapReading__Y_Pos QTapReading__TapDirection = QTapReading__TapDirection(0x0022)
|
|
|
|
QTapReading__Z_Pos QTapReading__TapDirection = QTapReading__TapDirection(0x0044)
|
|
|
|
QTapReading__X_Neg QTapReading__TapDirection = QTapReading__TapDirection(0x0101)
|
|
|
|
QTapReading__Y_Neg QTapReading__TapDirection = QTapReading__TapDirection(0x0202)
|
|
|
|
QTapReading__Z_Neg QTapReading__TapDirection = QTapReading__TapDirection(0x0404)
|
|
|
|
QTapReading__X_Both QTapReading__TapDirection = QTapReading__TapDirection(0x0111)
|
|
|
|
QTapReading__Y_Both QTapReading__TapDirection = QTapReading__TapDirection(0x0222)
|
|
|
|
QTapReading__Z_Both QTapReading__TapDirection = QTapReading__TapDirection(0x0444)
|
|
|
|
)
|
2017-01-27 22:22:58 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapReading) SetDoubleTap(doubleTap bool) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QTapReading_SetDoubleTap(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(doubleTap))))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapReading) SetTapDirection(tapDirection QTapReading__TapDirection) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QTapReading_SetTapDirection(ptr.Pointer(), C.longlong(tapDirection))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapReading) TapDirection() QTapReading__TapDirection {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return QTapReading__TapDirection(C.QTapReading_TapDirection(ptr.Pointer()))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapReading) IsDoubleTap() bool {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QTapReading_IsDoubleTap(ptr.Pointer()) != 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QTapSensor struct {
|
|
|
|
QSensor
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QTapSensor_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QTapSensor_PTR() *QTapSensor
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) QTapSensor_PTR() *QTapSensor {
|
|
|
|
return ptr
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQTapSensor(ptr QTapSensor_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QTapSensor_PTR().Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQTapSensorFromPointer(ptr unsafe.Pointer) *QTapSensor {
|
|
|
|
var n = new(QTapSensor)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
func NewQTapSensor(parent core.QObject_ITF) *QTapSensor {
|
|
|
|
var tmpValue = NewQTapSensorFromPointer(C.QTapSensor_NewQTapSensor(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQTapSensor_ReturnDoubleTapEventsChanged
|
|
|
|
func callbackQTapSensor_ReturnDoubleTapEventsChanged(ptr unsafe.Pointer, returnDoubleTapEvents C.char) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "returnDoubleTapEventsChanged"); signal != nil {
|
|
|
|
signal.(func(bool))(int8(returnDoubleTapEvents) != 0)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) ConnectReturnDoubleTapEventsChanged(f func(returnDoubleTapEvents bool)) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "returnDoubleTapEventsChanged") {
|
|
|
|
C.QTapSensor_ConnectReturnDoubleTapEventsChanged(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "returnDoubleTapEventsChanged"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "returnDoubleTapEventsChanged", func(returnDoubleTapEvents bool) {
|
|
|
|
signal.(func(bool))(returnDoubleTapEvents)
|
|
|
|
f(returnDoubleTapEvents)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "returnDoubleTapEventsChanged", f)
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) DisconnectReturnDoubleTapEventsChanged() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QTapSensor_DisconnectReturnDoubleTapEventsChanged(ptr.Pointer())
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "returnDoubleTapEventsChanged")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) ReturnDoubleTapEventsChanged(returnDoubleTapEvents bool) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QTapSensor_ReturnDoubleTapEventsChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(returnDoubleTapEvents))))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) SetReturnDoubleTapEvents(returnDoubleTapEvents bool) {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QTapSensor_SetReturnDoubleTapEvents(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(returnDoubleTapEvents))))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQTapSensor_DestroyQTapSensor
|
|
|
|
func callbackQTapSensor_DestroyQTapSensor(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QTapSensor"); signal != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
signal.(func())()
|
2016-04-30 20:03:25 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQTapSensorFromPointer(ptr).DestroyQTapSensorDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) ConnectDestroyQTapSensor(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QTapSensor"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QTapSensor", func() {
|
|
|
|
signal.(func())()
|
|
|
|
f()
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QTapSensor", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) DisconnectDestroyQTapSensor() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QTapSensor")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) DestroyQTapSensor() {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QTapSensor_DestroyQTapSensor(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) DestroyQTapSensorDefault() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QTapSensor_DestroyQTapSensorDefault(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) Reading() *QTapReading {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQTapReadingFromPointer(C.QTapSensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) ReturnDoubleTapEvents() bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QTapSensor_ReturnDoubleTapEvents(ptr.Pointer()) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QTapSensor_Type() string {
|
|
|
|
return cGoUnpackString(C.QTapSensor_QTapSensor_Type())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTapSensor) Type() string {
|
|
|
|
return cGoUnpackString(C.QTapSensor_QTapSensor_Type())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QTiltFilter struct {
|
|
|
|
QSensorFilter
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QTiltFilter_ITF interface {
|
|
|
|
QSensorFilter_ITF
|
|
|
|
QTiltFilter_PTR() *QTiltFilter
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltFilter) QTiltFilter_PTR() *QTiltFilter {
|
|
|
|
return ptr
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltFilter) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltFilter) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorFilter_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQTiltFilter(ptr QTiltFilter_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QTiltFilter_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQTiltFilterFromPointer(ptr unsafe.Pointer) *QTiltFilter {
|
|
|
|
var n = new(QTiltFilter)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltFilter) DestroyQTiltFilter() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQTiltFilter_Filter
|
|
|
|
func callbackQTiltFilter_Filter(ptr unsafe.Pointer, reading unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "filter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QTiltReading) bool)(NewQTiltReadingFromPointer(reading)))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltFilter) ConnectFilter(f func(reading *QTiltReading) bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-03-02 21:24:25 +03:00
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filter"); signal != nil {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", func(reading *QTiltReading) bool {
|
2017-03-10 19:40:29 +03:00
|
|
|
signal.(func(*QTiltReading) bool)(reading)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(reading)
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filter", f)
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltFilter) DisconnectFilter() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "filter")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltFilter) Filter(reading QTiltReading_ITF) bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return C.QTiltFilter_Filter(ptr.Pointer(), PointerFromQTiltReading(reading)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QTiltReading struct {
|
|
|
|
QSensorReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QTiltReading_ITF interface {
|
|
|
|
QSensorReading_ITF
|
|
|
|
QTiltReading_PTR() *QTiltReading
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltReading) QTiltReading_PTR() *QTiltReading {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltReading) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensorReading_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltReading) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensorReading_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQTiltReading(ptr QTiltReading_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QTiltReading_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQTiltReadingFromPointer(ptr unsafe.Pointer) *QTiltReading {
|
|
|
|
var n = new(QTiltReading)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltReading) DestroyQTiltReading() {
|
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
2016-08-26 20:43:21 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltReading) SetXRotation(x float64) {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QTiltReading_SetXRotation(ptr.Pointer(), C.double(x))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltReading) SetYRotation(y float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QTiltReading_SetYRotation(ptr.Pointer(), C.double(y))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltReading) XRotation() float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QTiltReading_XRotation(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltReading) YRotation() float64 {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return float64(C.QTiltReading_YRotation(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QTiltSensor struct {
|
|
|
|
QSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QTiltSensor_ITF interface {
|
|
|
|
QSensor_ITF
|
|
|
|
QTiltSensor_PTR() *QTiltSensor
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltSensor) QTiltSensor_PTR() *QTiltSensor {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltSensor) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltSensor) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QSensor_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQTiltSensor(ptr QTiltSensor_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QTiltSensor_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func NewQTiltSensorFromPointer(ptr unsafe.Pointer) *QTiltSensor {
|
|
|
|
var n = new(QTiltSensor)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
func NewQTiltSensor(parent core.QObject_ITF) *QTiltSensor {
|
|
|
|
var tmpValue = NewQTiltSensorFromPointer(C.QTiltSensor_NewQTiltSensor(core.PointerFromQObject(parent)))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltSensor) Calibrate() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QTiltSensor_Calibrate(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltSensor) DestroyQTiltSensor() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QTiltSensor_DestroyQTiltSensor(ptr.Pointer())
|
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QTiltSensor) Reading() *QTiltReading {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
var tmpValue = NewQTiltReadingFromPointer(C.QTiltSensor_Reading(ptr.Pointer()))
|
2017-05-31 00:01:01 +03:00
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QTiltSensor_Type() string {
|
|
|
|
return cGoUnpackString(C.QTiltSensor_QTiltSensor_Type())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTiltSensor) Type() string {
|
|
|
|
return cGoUnpackString(C.QTiltSensor_QTiltSensor_Type())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-12-11 23:03:06 +03:00
|
|
|
|
|
|
|
type QtMobility struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QtMobility_ITF interface {
|
|
|
|
QtMobility_PTR() *QtMobility
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QtMobility) QtMobility_PTR() *QtMobility {
|
|
|
|
return ptr
|
2016-12-11 23:03:06 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QtMobility) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-12-11 23:03:06 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QtMobility) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-12-11 23:03:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQtMobility(ptr QtMobility_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QtMobility_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQtMobilityFromPointer(ptr unsafe.Pointer) *QtMobility {
|
|
|
|
var n = new(QtMobility)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QtMobility) DestroyQtMobility() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
2016-12-11 23:03:06 +03:00
|
|
|
}
|
2017-01-18 21:28:40 +03:00
|
|
|
|
|
|
|
//go:generate stringer -type=QtMobility__SimulatorLightLevel
|
|
|
|
//QtMobility::SimulatorLightLevel
|
|
|
|
type QtMobility__SimulatorLightLevel int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QtMobility__Undefined QtMobility__SimulatorLightLevel = QtMobility__SimulatorLightLevel(0)
|
|
|
|
QtMobility__Dark QtMobility__SimulatorLightLevel = QtMobility__SimulatorLightLevel(1)
|
|
|
|
QtMobility__Twilight QtMobility__SimulatorLightLevel = QtMobility__SimulatorLightLevel(2)
|
|
|
|
QtMobility__Light QtMobility__SimulatorLightLevel = QtMobility__SimulatorLightLevel(3)
|
|
|
|
QtMobility__Bright QtMobility__SimulatorLightLevel = QtMobility__SimulatorLightLevel(4)
|
|
|
|
QtMobility__Sunny QtMobility__SimulatorLightLevel = QtMobility__SimulatorLightLevel(5)
|
|
|
|
)
|