2016-05-28 19:18:42 +03:00
|
|
|
// +build !minimal
|
|
|
|
|
2016-04-30 20:03:25 +03:00
|
|
|
package testlib
|
|
|
|
|
2016-08-23 23:51:01 +03:00
|
|
|
//#include <stdint.h>
|
2016-08-20 00:20:42 +03:00
|
|
|
//#include <stdlib.h>
|
2016-04-30 20:03:25 +03:00
|
|
|
//#include "testlib.h"
|
|
|
|
import "C"
|
|
|
|
import (
|
2016-08-23 23:51:01 +03:00
|
|
|
"fmt"
|
2016-04-30 20:03:25 +03:00
|
|
|
"github.com/therecipe/qt"
|
|
|
|
"github.com/therecipe/qt/core"
|
|
|
|
"github.com/therecipe/qt/widgets"
|
2016-08-23 23:51:01 +03:00
|
|
|
"runtime"
|
2016-04-30 20:03:25 +03:00
|
|
|
"unsafe"
|
|
|
|
)
|
|
|
|
|
|
|
|
type QSignalSpy struct {
|
|
|
|
core.QObject
|
|
|
|
core.QList
|
|
|
|
}
|
|
|
|
|
|
|
|
type QSignalSpy_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
core.QList_ITF
|
|
|
|
QSignalSpy_PTR() *QSignalSpy
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *QSignalSpy) QSignalSpy_PTR() *QSignalSpy {
|
|
|
|
return p
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *QSignalSpy) Pointer() unsafe.Pointer {
|
|
|
|
if p != nil {
|
|
|
|
return p.QObject_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *QSignalSpy) SetPointer(ptr unsafe.Pointer) {
|
|
|
|
if p != nil {
|
|
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
|
|
p.QList_PTR().SetPointer(ptr)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQSignalSpy(ptr QSignalSpy_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QSignalSpy_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQSignalSpyFromPointer(ptr unsafe.Pointer) *QSignalSpy {
|
|
|
|
var n = new(QSignalSpy)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
2016-08-20 00:20:42 +03:00
|
|
|
func (ptr *QSignalSpy) DestroyQSignalSpy() {
|
|
|
|
C.free(ptr.Pointer())
|
2016-08-26 20:43:21 +03:00
|
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))
|
2016-08-20 00:20:42 +03:00
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
|
2016-04-30 20:03:25 +03:00
|
|
|
func NewQSignalSpy(object core.QObject_ITF, sign string) *QSignalSpy {
|
2016-08-20 00:20:42 +03:00
|
|
|
var signC = C.CString(sign)
|
|
|
|
defer C.free(unsafe.Pointer(signC))
|
2016-08-24 18:00:49 +03:00
|
|
|
var tmpValue = NewQSignalSpyFromPointer(C.QSignalSpy_NewQSignalSpy(core.PointerFromQObject(object), signC))
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::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-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) IsValid() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return C.QSignalSpy_IsValid(ptr.Pointer()) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) Signal() string {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-21 18:04:39 +03:00
|
|
|
return qt.HexDecodeToString(C.GoString(C.QSignalSpy_Signal(ptr.Pointer())))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) Wait(timeout int) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
return C.QSignalSpy_Wait(ptr.Pointer(), C.int(int32(timeout))) != 0
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQSignalSpy_TimerEvent
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQSignalSpy_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2016-04-30 20:03:25 +03:00
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSignalSpy::timerEvent"); signal != nil {
|
2016-04-30 20:03:25 +03:00
|
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQSignalSpyFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::timerEvent", f)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DisconnectTimerEvent() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::timerEvent")
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) TimerEvent(event core.QTimerEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSignalSpy_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSignalSpy_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQSignalSpy_ChildEvent
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQSignalSpy_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2016-04-30 20:03:25 +03:00
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSignalSpy::childEvent"); signal != nil {
|
2016-04-30 20:03:25 +03:00
|
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQSignalSpyFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ConnectChildEvent(f func(event *core.QChildEvent)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::childEvent", f)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DisconnectChildEvent() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::childEvent")
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ChildEvent(event core.QChildEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSignalSpy_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSignalSpy_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQSignalSpy_ConnectNotify
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQSignalSpy_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2016-04-30 20:03:25 +03:00
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSignalSpy::connectNotify"); signal != nil {
|
2016-04-30 20:03:25 +03:00
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
|
|
|
NewQSignalSpyFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ConnectConnectNotify(f func(sign *core.QMetaMethod)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::connectNotify", f)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DisconnectConnectNotify() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::connectNotify")
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ConnectNotify(sign core.QMetaMethod_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSignalSpy_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSignalSpy_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQSignalSpy_CustomEvent
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQSignalSpy_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2016-04-30 20:03:25 +03:00
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSignalSpy::customEvent"); signal != nil {
|
2016-04-30 20:03:25 +03:00
|
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQSignalSpyFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ConnectCustomEvent(f func(event *core.QEvent)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::customEvent", f)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DisconnectCustomEvent() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::customEvent")
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) CustomEvent(event core.QEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSignalSpy_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) CustomEventDefault(event core.QEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSignalSpy_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQSignalSpy_DeleteLater
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQSignalSpy_DeleteLater(ptr unsafe.Pointer) {
|
2016-08-24 18:00:49 +03:00
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSignalSpy::deleteLater"); signal != nil {
|
2016-04-30 20:03:25 +03:00
|
|
|
signal.(func())()
|
|
|
|
} else {
|
|
|
|
NewQSignalSpyFromPointer(ptr).DeleteLaterDefault()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ConnectDeleteLater(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::deleteLater", f)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DisconnectDeleteLater() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::deleteLater")
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DeleteLater() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSignalSpy_DeleteLater(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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DeleteLaterDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSignalSpy_DeleteLaterDefault(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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQSignalSpy_DisconnectNotify
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQSignalSpy_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2016-04-30 20:03:25 +03:00
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSignalSpy::disconnectNotify"); signal != nil {
|
2016-04-30 20:03:25 +03:00
|
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
} else {
|
|
|
|
NewQSignalSpyFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ConnectDisconnectNotify(f func(sign *core.QMetaMethod)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::disconnectNotify", f)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DisconnectDisconnectNotify() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::disconnectNotify")
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DisconnectNotify(sign core.QMetaMethod_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSignalSpy_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QSignalSpy_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQSignalSpy_Event
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQSignalSpy_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
2016-04-30 20:03:25 +03:00
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSignalSpy::event"); signal != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2016-08-23 23:51:01 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSignalSpyFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ConnectEvent(f func(e *core.QEvent) bool) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::event", f)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DisconnectEvent() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::event")
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) Event(e core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return C.QSignalSpy_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) EventDefault(e core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return C.QSignalSpy_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQSignalSpy_EventFilter
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQSignalSpy_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
2016-04-30 20:03:25 +03:00
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSignalSpy::eventFilter"); signal != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2016-08-23 23:51:01 +03:00
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSignalSpyFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ConnectEventFilter(f func(watched *core.QObject, event *core.QEvent) bool) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::eventFilter", f)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DisconnectEventFilter() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::eventFilter")
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return C.QSignalSpy_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return C.QSignalSpy_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQSignalSpy_MetaObject
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQSignalSpy_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
2016-04-30 20:03:25 +03:00
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSignalSpy::metaObject"); signal != nil {
|
2016-04-30 20:03:25 +03:00
|
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
|
|
}
|
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQSignalSpyFromPointer(ptr).MetaObjectDefault())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) ConnectMetaObject(f func() *core.QMetaObject) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::metaObject", f)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) DisconnectMetaObject() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2016-08-24 18:00:49 +03:00
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSignalSpy::metaObject")
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) MetaObject() *core.QMetaObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return core.NewQMetaObjectFromPointer(C.QSignalSpy_MetaObject(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QSignalSpy) MetaObjectDefault() *core.QMetaObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return core.NewQMetaObjectFromPointer(C.QSignalSpy_MetaObjectDefault(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
type QTestEventList struct {
|
|
|
|
core.QList
|
|
|
|
}
|
|
|
|
|
|
|
|
type QTestEventList_ITF interface {
|
|
|
|
core.QList_ITF
|
|
|
|
QTestEventList_PTR() *QTestEventList
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *QTestEventList) QTestEventList_PTR() *QTestEventList {
|
|
|
|
return p
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *QTestEventList) Pointer() unsafe.Pointer {
|
|
|
|
if p != nil {
|
|
|
|
return p.QList_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *QTestEventList) SetPointer(ptr unsafe.Pointer) {
|
|
|
|
if p != nil {
|
|
|
|
p.QList_PTR().SetPointer(ptr)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQTestEventList(ptr QTestEventList_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QTestEventList_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQTestEventListFromPointer(ptr unsafe.Pointer) *QTestEventList {
|
|
|
|
var n = new(QTestEventList)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
func NewQTestEventList() *QTestEventList {
|
2016-08-23 23:51:01 +03:00
|
|
|
var tmpValue = NewQTestEventListFromPointer(C.QTestEventList_NewQTestEventList())
|
|
|
|
runtime.SetFinalizer(tmpValue, (*QTestEventList).DestroyQTestEventList)
|
|
|
|
return tmpValue
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewQTestEventList2(other QTestEventList_ITF) *QTestEventList {
|
2016-08-23 23:51:01 +03:00
|
|
|
var tmpValue = NewQTestEventListFromPointer(C.QTestEventList_NewQTestEventList2(PointerFromQTestEventList(other)))
|
|
|
|
runtime.SetFinalizer(tmpValue, (*QTestEventList).DestroyQTestEventList)
|
|
|
|
return tmpValue
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddDelay(msecs int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddDelay(ptr.Pointer(), C.int(int32(msecs)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddKeyClick(qtKey core.Qt__Key, modifiers core.Qt__KeyboardModifier, msecs int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddKeyClick(ptr.Pointer(), C.longlong(qtKey), C.longlong(modifiers), C.int(int32(msecs)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddKeyClick2(ascii string, modifiers core.Qt__KeyboardModifier, msecs int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-20 00:20:42 +03:00
|
|
|
var asciiC = C.CString(ascii)
|
|
|
|
defer C.free(unsafe.Pointer(asciiC))
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddKeyClick2(ptr.Pointer(), asciiC, C.longlong(modifiers), C.int(int32(msecs)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddKeyClicks(keys string, modifiers core.Qt__KeyboardModifier, msecs int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-20 00:20:42 +03:00
|
|
|
var keysC = C.CString(keys)
|
|
|
|
defer C.free(unsafe.Pointer(keysC))
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddKeyClicks(ptr.Pointer(), keysC, C.longlong(modifiers), C.int(int32(msecs)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddKeyPress(qtKey core.Qt__Key, modifiers core.Qt__KeyboardModifier, msecs int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddKeyPress(ptr.Pointer(), C.longlong(qtKey), C.longlong(modifiers), C.int(int32(msecs)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddKeyPress2(ascii string, modifiers core.Qt__KeyboardModifier, msecs int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-20 00:20:42 +03:00
|
|
|
var asciiC = C.CString(ascii)
|
|
|
|
defer C.free(unsafe.Pointer(asciiC))
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddKeyPress2(ptr.Pointer(), asciiC, C.longlong(modifiers), C.int(int32(msecs)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddKeyRelease(qtKey core.Qt__Key, modifiers core.Qt__KeyboardModifier, msecs int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddKeyRelease(ptr.Pointer(), C.longlong(qtKey), C.longlong(modifiers), C.int(int32(msecs)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddKeyRelease2(ascii string, modifiers core.Qt__KeyboardModifier, msecs int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-20 00:20:42 +03:00
|
|
|
var asciiC = C.CString(ascii)
|
|
|
|
defer C.free(unsafe.Pointer(asciiC))
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddKeyRelease2(ptr.Pointer(), asciiC, C.longlong(modifiers), C.int(int32(msecs)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddMouseClick(button core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier, pos core.QPoint_ITF, delay int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddMouseClick(ptr.Pointer(), C.longlong(button), C.longlong(modifiers), core.PointerFromQPoint(pos), C.int(int32(delay)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddMouseDClick(button core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier, pos core.QPoint_ITF, delay int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddMouseDClick(ptr.Pointer(), C.longlong(button), C.longlong(modifiers), core.PointerFromQPoint(pos), C.int(int32(delay)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddMouseMove(pos core.QPoint_ITF, delay int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddMouseMove(ptr.Pointer(), core.PointerFromQPoint(pos), C.int(int32(delay)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddMousePress(button core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier, pos core.QPoint_ITF, delay int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddMousePress(ptr.Pointer(), C.longlong(button), C.longlong(modifiers), core.PointerFromQPoint(pos), C.int(int32(delay)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) AddMouseRelease(button core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier, pos core.QPoint_ITF, delay int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QTestEventList_AddMouseRelease(ptr.Pointer(), C.longlong(button), C.longlong(modifiers), core.PointerFromQPoint(pos), C.int(int32(delay)))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) Clear() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QTestEventList_Clear(ptr.Pointer())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) Simulate(w widgets.QWidget_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QTestEventList_Simulate(ptr.Pointer(), widgets.PointerFromQWidget(w))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QTestEventList) DestroyQTestEventList() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QTestEventList_DestroyQTestEventList(ptr.Pointer())
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|