mirror of
https://github.com/bluszcz/cutego.git
synced 2024-09-28 21:25:16 +03:00
78231 lines
2.2 MiB
Executable file
78231 lines
2.2 MiB
Executable file
package core
|
|
|
|
//#include "core.h"
|
|
import "C"
|
|
import (
|
|
"github.com/therecipe/qt"
|
|
"strings"
|
|
"unsafe"
|
|
)
|
|
|
|
//QAbstractAnimation::DeletionPolicy
|
|
type QAbstractAnimation__DeletionPolicy int64
|
|
|
|
const (
|
|
QAbstractAnimation__KeepWhenStopped = QAbstractAnimation__DeletionPolicy(0)
|
|
QAbstractAnimation__DeleteWhenStopped = QAbstractAnimation__DeletionPolicy(1)
|
|
)
|
|
|
|
//QAbstractAnimation::Direction
|
|
type QAbstractAnimation__Direction int64
|
|
|
|
const (
|
|
QAbstractAnimation__Forward = QAbstractAnimation__Direction(0)
|
|
QAbstractAnimation__Backward = QAbstractAnimation__Direction(1)
|
|
)
|
|
|
|
//QAbstractAnimation::State
|
|
type QAbstractAnimation__State int64
|
|
|
|
const (
|
|
QAbstractAnimation__Stopped = QAbstractAnimation__State(0)
|
|
QAbstractAnimation__Paused = QAbstractAnimation__State(1)
|
|
QAbstractAnimation__Running = QAbstractAnimation__State(2)
|
|
)
|
|
|
|
type QAbstractAnimation struct {
|
|
QObject
|
|
}
|
|
|
|
type QAbstractAnimation_ITF interface {
|
|
QObject_ITF
|
|
QAbstractAnimation_PTR() *QAbstractAnimation
|
|
}
|
|
|
|
func (p *QAbstractAnimation) QAbstractAnimation_PTR() *QAbstractAnimation {
|
|
return p
|
|
}
|
|
|
|
func (p *QAbstractAnimation) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAbstractAnimation) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractAnimation(ptr QAbstractAnimation_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAnimation_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractAnimationFromPointer(ptr unsafe.Pointer) *QAbstractAnimation {
|
|
var n = new(QAbstractAnimation)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAbstractAnimationFromPointer(ptr unsafe.Pointer) *QAbstractAnimation {
|
|
var n = NewQAbstractAnimationFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QAbstractAnimation_") {
|
|
n.SetObjectName("QAbstractAnimation_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) CurrentLoop() int {
|
|
defer qt.Recovering("QAbstractAnimation::currentLoop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractAnimation_CurrentLoop(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) CurrentTime() int {
|
|
defer qt.Recovering("QAbstractAnimation::currentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractAnimation_CurrentTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) Direction() QAbstractAnimation__Direction {
|
|
defer qt.Recovering("QAbstractAnimation::direction")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractAnimation__Direction(C.QAbstractAnimation_Direction(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) LoopCount() int {
|
|
defer qt.Recovering("QAbstractAnimation::loopCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractAnimation_LoopCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_SetCurrentTime
|
|
func callbackQAbstractAnimation_SetCurrentTime(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) {
|
|
defer qt.Recovering("callback QAbstractAnimation::setCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(msecs))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectSetCurrentTime(f func(msecs int)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectSetCurrentTime(msecs int) {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) SetCurrentTime(msecs int) {
|
|
defer qt.Recovering("QAbstractAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_SetCurrentTime(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) SetDirection(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QAbstractAnimation::setDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_SetDirection(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) SetLoopCount(loopCount int) {
|
|
defer qt.Recovering("QAbstractAnimation::setLoopCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_SetLoopCount(ptr.Pointer(), C.int(loopCount))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) State() QAbstractAnimation__State {
|
|
defer qt.Recovering("QAbstractAnimation::state")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractAnimation__State(C.QAbstractAnimation_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func NewQAbstractAnimation(parent QObject_ITF) *QAbstractAnimation {
|
|
defer qt.Recovering("QAbstractAnimation::QAbstractAnimation")
|
|
|
|
return newQAbstractAnimationFromPointer(C.QAbstractAnimation_NewQAbstractAnimation(PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_CurrentLoopChanged
|
|
func callbackQAbstractAnimation_CurrentLoopChanged(ptr unsafe.Pointer, ptrName *C.char, currentLoop C.int) {
|
|
defer qt.Recovering("callback QAbstractAnimation::currentLoopChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "currentLoopChanged"); signal != nil {
|
|
signal.(func(int))(int(currentLoop))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectCurrentLoopChanged(f func(currentLoop int)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::currentLoopChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_ConnectCurrentLoopChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "currentLoopChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectCurrentLoopChanged() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::currentLoopChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_DisconnectCurrentLoopChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "currentLoopChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) CurrentLoopChanged(currentLoop int) {
|
|
defer qt.Recovering("QAbstractAnimation::currentLoopChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_CurrentLoopChanged(ptr.Pointer(), C.int(currentLoop))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) CurrentLoopTime() int {
|
|
defer qt.Recovering("QAbstractAnimation::currentLoopTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractAnimation_CurrentLoopTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_DirectionChanged
|
|
func callbackQAbstractAnimation_DirectionChanged(ptr unsafe.Pointer, ptrName *C.char, newDirection C.int) {
|
|
defer qt.Recovering("callback QAbstractAnimation::directionChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "directionChanged"); signal != nil {
|
|
signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(newDirection))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectDirectionChanged(f func(newDirection QAbstractAnimation__Direction)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::directionChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_ConnectDirectionChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "directionChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectDirectionChanged() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::directionChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_DisconnectDirectionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "directionChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DirectionChanged(newDirection QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QAbstractAnimation::directionChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_DirectionChanged(ptr.Pointer(), C.int(newDirection))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_Duration
|
|
func callbackQAbstractAnimation_Duration(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractAnimation::duration")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "duration"); signal != nil {
|
|
return C.int(signal.(func() int)())
|
|
}
|
|
|
|
return C.int(0)
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectDuration(f func() int) {
|
|
defer qt.Recovering("connect QAbstractAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "duration", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectDuration() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) Duration() int {
|
|
defer qt.Recovering("QAbstractAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractAnimation_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_Event
|
|
func callbackQAbstractAnimation_Event(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractAnimation::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractAnimationFromPointer(ptr).EventDefault(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectEvent(f func(event *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) Event(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractAnimation_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) EventDefault(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractAnimation_EventDefault(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_Finished
|
|
func callbackQAbstractAnimation_Finished(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractAnimation::finished")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "finished"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectFinished(f func()) {
|
|
defer qt.Recovering("connect QAbstractAnimation::finished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_ConnectFinished(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "finished", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectFinished() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::finished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_DisconnectFinished(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "finished")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) Finished() {
|
|
defer qt.Recovering("QAbstractAnimation::finished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_Finished(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) Group() *QAnimationGroup {
|
|
defer qt.Recovering("QAbstractAnimation::group")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAnimationGroupFromPointer(C.QAbstractAnimation_Group(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_Pause
|
|
func callbackQAbstractAnimation_Pause(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractAnimation::pause")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pause"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectPause(f func()) {
|
|
defer qt.Recovering("connect QAbstractAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pause", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectPause() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pause")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) Pause() {
|
|
defer qt.Recovering("QAbstractAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_Pause(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_Resume
|
|
func callbackQAbstractAnimation_Resume(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractAnimation::resume")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resume"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectResume(f func()) {
|
|
defer qt.Recovering("connect QAbstractAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resume", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectResume() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) Resume() {
|
|
defer qt.Recovering("QAbstractAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_Resume(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_SetPaused
|
|
func callbackQAbstractAnimation_SetPaused(ptr unsafe.Pointer, ptrName *C.char, paused C.int) {
|
|
defer qt.Recovering("callback QAbstractAnimation::setPaused")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setPaused"); signal != nil {
|
|
signal.(func(bool))(int(paused) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectSetPaused(f func(paused bool)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setPaused", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectSetPaused(paused bool) {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setPaused")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) SetPaused(paused bool) {
|
|
defer qt.Recovering("QAbstractAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_SetPaused(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_Start
|
|
func callbackQAbstractAnimation_Start(ptr unsafe.Pointer, ptrName *C.char, policy C.int) {
|
|
defer qt.Recovering("callback QAbstractAnimation::start")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "start"); signal != nil {
|
|
signal.(func(QAbstractAnimation__DeletionPolicy))(QAbstractAnimation__DeletionPolicy(policy))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectStart(f func(policy QAbstractAnimation__DeletionPolicy)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "start", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectStart(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) Start(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QAbstractAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_Start(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_StateChanged
|
|
func callbackQAbstractAnimation_StateChanged(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
|
|
defer qt.Recovering("callback QAbstractAnimation::stateChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stateChanged"); signal != nil {
|
|
signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectStateChanged(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::stateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_ConnectStateChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "stateChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectStateChanged() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::stateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) StateChanged(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QAbstractAnimation::stateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_StateChanged(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_Stop
|
|
func callbackQAbstractAnimation_Stop(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractAnimation::stop")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stop"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectStop(f func()) {
|
|
defer qt.Recovering("connect QAbstractAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "stop", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectStop() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) Stop() {
|
|
defer qt.Recovering("QAbstractAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) TotalDuration() int {
|
|
defer qt.Recovering("QAbstractAnimation::totalDuration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractAnimation_TotalDuration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_UpdateCurrentTime
|
|
func callbackQAbstractAnimation_UpdateCurrentTime(ptr unsafe.Pointer, ptrName *C.char, currentTime C.int) {
|
|
defer qt.Recovering("callback QAbstractAnimation::updateCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(currentTime))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectUpdateCurrentTime(f func(currentTime int)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectUpdateCurrentTime(currentTime int) {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) UpdateCurrentTime(currentTime int) {
|
|
defer qt.Recovering("QAbstractAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_UpdateCurrentTime(ptr.Pointer(), C.int(currentTime))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_UpdateDirection
|
|
func callbackQAbstractAnimation_UpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
|
|
defer qt.Recovering("callback QAbstractAnimation::updateDirection")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
|
|
signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
|
|
} else {
|
|
NewQAbstractAnimationFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectUpdateDirection() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateDirection")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) UpdateDirection(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QAbstractAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_UpdateDirection(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QAbstractAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_UpdateState
|
|
func callbackQAbstractAnimation_UpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
|
|
defer qt.Recovering("callback QAbstractAnimation::updateState")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
|
|
signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
} else {
|
|
NewQAbstractAnimationFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectUpdateState() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateState")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QAbstractAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QAbstractAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DestroyQAbstractAnimation() {
|
|
defer qt.Recovering("QAbstractAnimation::~QAbstractAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractAnimation_DestroyQAbstractAnimation(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_TimerEvent
|
|
func callbackQAbstractAnimation_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractAnimation::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractAnimationFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_ChildEvent
|
|
func callbackQAbstractAnimation_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractAnimation::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractAnimationFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_ConnectNotify
|
|
func callbackQAbstractAnimation_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractAnimation::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractAnimationFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_CustomEvent
|
|
func callbackQAbstractAnimation_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractAnimation::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractAnimationFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_DeleteLater
|
|
func callbackQAbstractAnimation_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractAnimation::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractAnimationFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QAbstractAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DeleteLater() {
|
|
defer qt.Recovering("QAbstractAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractAnimation_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DeleteLaterDefault() {
|
|
defer qt.Recovering("QAbstractAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractAnimation_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_DisconnectNotify
|
|
func callbackQAbstractAnimation_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractAnimation::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractAnimationFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAnimation_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_EventFilter
|
|
func callbackQAbstractAnimation_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractAnimation::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractAnimationFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractAnimation_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractAnimation_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractAnimation_MetaObject
|
|
func callbackQAbstractAnimation_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractAnimation::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQAbstractAnimationFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QAbstractAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QAbstractAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QAbstractAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractAnimation_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAnimation) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QAbstractAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractAnimation_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAbstractEventDispatcher struct {
|
|
QObject
|
|
}
|
|
|
|
type QAbstractEventDispatcher_ITF interface {
|
|
QObject_ITF
|
|
QAbstractEventDispatcher_PTR() *QAbstractEventDispatcher
|
|
}
|
|
|
|
func (p *QAbstractEventDispatcher) QAbstractEventDispatcher_PTR() *QAbstractEventDispatcher {
|
|
return p
|
|
}
|
|
|
|
func (p *QAbstractEventDispatcher) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAbstractEventDispatcher) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractEventDispatcher(ptr QAbstractEventDispatcher_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractEventDispatcher_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractEventDispatcherFromPointer(ptr unsafe.Pointer) *QAbstractEventDispatcher {
|
|
var n = new(QAbstractEventDispatcher)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAbstractEventDispatcherFromPointer(ptr unsafe.Pointer) *QAbstractEventDispatcher {
|
|
var n = NewQAbstractEventDispatcherFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QAbstractEventDispatcher_") {
|
|
n.SetObjectName("QAbstractEventDispatcher_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_AboutToBlock
|
|
func callbackQAbstractEventDispatcher_AboutToBlock(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::aboutToBlock")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "aboutToBlock"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectAboutToBlock(f func()) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::aboutToBlock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_ConnectAboutToBlock(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "aboutToBlock", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectAboutToBlock() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::aboutToBlock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_DisconnectAboutToBlock(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "aboutToBlock")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) AboutToBlock() {
|
|
defer qt.Recovering("QAbstractEventDispatcher::aboutToBlock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_AboutToBlock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_Awake
|
|
func callbackQAbstractEventDispatcher_Awake(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::awake")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "awake"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectAwake(f func()) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::awake")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_ConnectAwake(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "awake", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectAwake() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::awake")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_DisconnectAwake(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "awake")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) Awake() {
|
|
defer qt.Recovering("QAbstractEventDispatcher::awake")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_Awake(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) FilterNativeEvent(eventType string, message unsafe.Pointer, result int) bool {
|
|
defer qt.Recovering("QAbstractEventDispatcher::filterNativeEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractEventDispatcher_FilterNativeEvent(ptr.Pointer(), C.CString(eventType), message, C.long(result)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_Flush
|
|
func callbackQAbstractEventDispatcher_Flush(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::flush")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "flush"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectFlush(f func()) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::flush")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "flush", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectFlush() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::flush")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "flush")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) Flush() {
|
|
defer qt.Recovering("QAbstractEventDispatcher::flush")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_Flush(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) InstallNativeEventFilter(filterObj QAbstractNativeEventFilter_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::installNativeEventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_InstallNativeEventFilter(ptr.Pointer(), PointerFromQAbstractNativeEventFilter(filterObj))
|
|
}
|
|
}
|
|
|
|
func QAbstractEventDispatcher_Instance(thread QThread_ITF) *QAbstractEventDispatcher {
|
|
defer qt.Recovering("QAbstractEventDispatcher::instance")
|
|
|
|
return NewQAbstractEventDispatcherFromPointer(C.QAbstractEventDispatcher_QAbstractEventDispatcher_Instance(PointerFromQThread(thread)))
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) Instance(thread QThread_ITF) *QAbstractEventDispatcher {
|
|
defer qt.Recovering("QAbstractEventDispatcher::instance")
|
|
|
|
return NewQAbstractEventDispatcherFromPointer(C.QAbstractEventDispatcher_QAbstractEventDispatcher_Instance(PointerFromQThread(thread)))
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_Interrupt
|
|
func callbackQAbstractEventDispatcher_Interrupt(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::interrupt")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "interrupt"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectInterrupt(f func()) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::interrupt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "interrupt", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectInterrupt() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::interrupt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "interrupt")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) Interrupt() {
|
|
defer qt.Recovering("QAbstractEventDispatcher::interrupt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_Interrupt(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_ProcessEvents
|
|
func callbackQAbstractEventDispatcher_ProcessEvents(ptr unsafe.Pointer, ptrName *C.char, flags C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::processEvents")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "processEvents"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(QEventLoop__ProcessEventsFlag) bool)(QEventLoop__ProcessEventsFlag(flags))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(false))
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectProcessEvents(f func(flags QEventLoop__ProcessEventsFlag) bool) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::processEvents")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "processEvents", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectProcessEvents(flags QEventLoop__ProcessEventsFlag) {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::processEvents")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "processEvents")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ProcessEvents(flags QEventLoop__ProcessEventsFlag) bool {
|
|
defer qt.Recovering("QAbstractEventDispatcher::processEvents")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractEventDispatcher_ProcessEvents(ptr.Pointer(), C.int(flags)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_RegisterEventNotifier
|
|
func callbackQAbstractEventDispatcher_RegisterEventNotifier(ptr unsafe.Pointer, ptrName *C.char, notifier unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::registerEventNotifier")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "registerEventNotifier"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QWinEventNotifier) bool)(NewQWinEventNotifierFromPointer(notifier))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(false))
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectRegisterEventNotifier(f func(notifier *QWinEventNotifier) bool) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::registerEventNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "registerEventNotifier", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectRegisterEventNotifier(notifier QWinEventNotifier_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::registerEventNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "registerEventNotifier")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) RegisterEventNotifier(notifier QWinEventNotifier_ITF) bool {
|
|
defer qt.Recovering("QAbstractEventDispatcher::registerEventNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractEventDispatcher_RegisterEventNotifier(ptr.Pointer(), PointerFromQWinEventNotifier(notifier)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_RegisterSocketNotifier
|
|
func callbackQAbstractEventDispatcher_RegisterSocketNotifier(ptr unsafe.Pointer, ptrName *C.char, notifier unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::registerSocketNotifier")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "registerSocketNotifier"); signal != nil {
|
|
signal.(func(*QSocketNotifier))(NewQSocketNotifierFromPointer(notifier))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectRegisterSocketNotifier(f func(notifier *QSocketNotifier)) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::registerSocketNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "registerSocketNotifier", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectRegisterSocketNotifier(notifier QSocketNotifier_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::registerSocketNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "registerSocketNotifier")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) RegisterSocketNotifier(notifier QSocketNotifier_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::registerSocketNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_RegisterSocketNotifier(ptr.Pointer(), PointerFromQSocketNotifier(notifier))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) RegisterTimer(interval int, timerType Qt__TimerType, object QObject_ITF) int {
|
|
defer qt.Recovering("QAbstractEventDispatcher::registerTimer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractEventDispatcher_RegisterTimer(ptr.Pointer(), C.int(interval), C.int(timerType), PointerFromQObject(object)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_RegisterTimer4
|
|
func callbackQAbstractEventDispatcher_RegisterTimer4(ptr unsafe.Pointer, ptrName *C.char, timerId C.int, interval C.int, timerType C.int, object unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::registerTimer")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "registerTimer4"); signal != nil {
|
|
signal.(func(int, int, Qt__TimerType, *QObject))(int(timerId), int(interval), Qt__TimerType(timerType), NewQObjectFromPointer(object))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectRegisterTimer4(f func(timerId int, interval int, timerType Qt__TimerType, object *QObject)) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::registerTimer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "registerTimer4", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectRegisterTimer4(timerId int, interval int, timerType Qt__TimerType, object QObject_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::registerTimer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "registerTimer4")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) RegisterTimer4(timerId int, interval int, timerType Qt__TimerType, object QObject_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::registerTimer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_RegisterTimer4(ptr.Pointer(), C.int(timerId), C.int(interval), C.int(timerType), PointerFromQObject(object))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_RemainingTime
|
|
func callbackQAbstractEventDispatcher_RemainingTime(ptr unsafe.Pointer, ptrName *C.char, timerId C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::remainingTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "remainingTime"); signal != nil {
|
|
return C.int(signal.(func(int) int)(int(timerId)))
|
|
}
|
|
|
|
return C.int(0)
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectRemainingTime(f func(timerId int) int) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::remainingTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "remainingTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectRemainingTime(timerId int) {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::remainingTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "remainingTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) RemainingTime(timerId int) int {
|
|
defer qt.Recovering("QAbstractEventDispatcher::remainingTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractEventDispatcher_RemainingTime(ptr.Pointer(), C.int(timerId)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) RemoveNativeEventFilter(filter QAbstractNativeEventFilter_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::removeNativeEventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_RemoveNativeEventFilter(ptr.Pointer(), PointerFromQAbstractNativeEventFilter(filter))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_UnregisterEventNotifier
|
|
func callbackQAbstractEventDispatcher_UnregisterEventNotifier(ptr unsafe.Pointer, ptrName *C.char, notifier unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::unregisterEventNotifier")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "unregisterEventNotifier"); signal != nil {
|
|
signal.(func(*QWinEventNotifier))(NewQWinEventNotifierFromPointer(notifier))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectUnregisterEventNotifier(f func(notifier *QWinEventNotifier)) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::unregisterEventNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "unregisterEventNotifier", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectUnregisterEventNotifier(notifier QWinEventNotifier_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::unregisterEventNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "unregisterEventNotifier")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) UnregisterEventNotifier(notifier QWinEventNotifier_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::unregisterEventNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_UnregisterEventNotifier(ptr.Pointer(), PointerFromQWinEventNotifier(notifier))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_UnregisterSocketNotifier
|
|
func callbackQAbstractEventDispatcher_UnregisterSocketNotifier(ptr unsafe.Pointer, ptrName *C.char, notifier unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::unregisterSocketNotifier")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "unregisterSocketNotifier"); signal != nil {
|
|
signal.(func(*QSocketNotifier))(NewQSocketNotifierFromPointer(notifier))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectUnregisterSocketNotifier(f func(notifier *QSocketNotifier)) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::unregisterSocketNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "unregisterSocketNotifier", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectUnregisterSocketNotifier(notifier QSocketNotifier_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::unregisterSocketNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "unregisterSocketNotifier")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) UnregisterSocketNotifier(notifier QSocketNotifier_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::unregisterSocketNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_UnregisterSocketNotifier(ptr.Pointer(), PointerFromQSocketNotifier(notifier))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_UnregisterTimer
|
|
func callbackQAbstractEventDispatcher_UnregisterTimer(ptr unsafe.Pointer, ptrName *C.char, timerId C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::unregisterTimer")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "unregisterTimer"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(timerId))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(false))
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectUnregisterTimer(f func(timerId int) bool) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::unregisterTimer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "unregisterTimer", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectUnregisterTimer(timerId int) {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::unregisterTimer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "unregisterTimer")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) UnregisterTimer(timerId int) bool {
|
|
defer qt.Recovering("QAbstractEventDispatcher::unregisterTimer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractEventDispatcher_UnregisterTimer(ptr.Pointer(), C.int(timerId)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_UnregisterTimers
|
|
func callbackQAbstractEventDispatcher_UnregisterTimers(ptr unsafe.Pointer, ptrName *C.char, object unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::unregisterTimers")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "unregisterTimers"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject) bool)(NewQObjectFromPointer(object))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(false))
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectUnregisterTimers(f func(object *QObject) bool) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::unregisterTimers")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "unregisterTimers", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectUnregisterTimers(object QObject_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::unregisterTimers")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "unregisterTimers")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) UnregisterTimers(object QObject_ITF) bool {
|
|
defer qt.Recovering("QAbstractEventDispatcher::unregisterTimers")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractEventDispatcher_UnregisterTimers(ptr.Pointer(), PointerFromQObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_WakeUp
|
|
func callbackQAbstractEventDispatcher_WakeUp(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::wakeUp")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "wakeUp"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectWakeUp(f func()) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::wakeUp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "wakeUp", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectWakeUp() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::wakeUp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "wakeUp")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) WakeUp() {
|
|
defer qt.Recovering("QAbstractEventDispatcher::wakeUp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_WakeUp(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DestroyQAbstractEventDispatcher() {
|
|
defer qt.Recovering("QAbstractEventDispatcher::~QAbstractEventDispatcher")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractEventDispatcher_DestroyQAbstractEventDispatcher(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_TimerEvent
|
|
func callbackQAbstractEventDispatcher_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractEventDispatcherFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_ChildEvent
|
|
func callbackQAbstractEventDispatcher_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractEventDispatcherFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_ConnectNotify
|
|
func callbackQAbstractEventDispatcher_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractEventDispatcherFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_CustomEvent
|
|
func callbackQAbstractEventDispatcher_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractEventDispatcherFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_DeleteLater
|
|
func callbackQAbstractEventDispatcher_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractEventDispatcherFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DeleteLater() {
|
|
defer qt.Recovering("QAbstractEventDispatcher::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractEventDispatcher_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DeleteLaterDefault() {
|
|
defer qt.Recovering("QAbstractEventDispatcher::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractEventDispatcher_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_DisconnectNotify
|
|
func callbackQAbstractEventDispatcher_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractEventDispatcherFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractEventDispatcher::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractEventDispatcher_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_Event
|
|
func callbackQAbstractEventDispatcher_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractEventDispatcherFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractEventDispatcher::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractEventDispatcher_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractEventDispatcher::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractEventDispatcher_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_EventFilter
|
|
func callbackQAbstractEventDispatcher_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractEventDispatcherFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractEventDispatcher::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractEventDispatcher_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractEventDispatcher::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractEventDispatcher_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractEventDispatcher_MetaObject
|
|
func callbackQAbstractEventDispatcher_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractEventDispatcher::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQAbstractEventDispatcherFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QAbstractEventDispatcher::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QAbstractEventDispatcher::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QAbstractEventDispatcher::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractEventDispatcher_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractEventDispatcher) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QAbstractEventDispatcher::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractEventDispatcher_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//QAbstractItemModel::LayoutChangeHint
|
|
type QAbstractItemModel__LayoutChangeHint int64
|
|
|
|
const (
|
|
QAbstractItemModel__NoLayoutChangeHint = QAbstractItemModel__LayoutChangeHint(0)
|
|
QAbstractItemModel__VerticalSortHint = QAbstractItemModel__LayoutChangeHint(1)
|
|
QAbstractItemModel__HorizontalSortHint = QAbstractItemModel__LayoutChangeHint(2)
|
|
)
|
|
|
|
type QAbstractItemModel struct {
|
|
QObject
|
|
}
|
|
|
|
type QAbstractItemModel_ITF interface {
|
|
QObject_ITF
|
|
QAbstractItemModel_PTR() *QAbstractItemModel
|
|
}
|
|
|
|
func (p *QAbstractItemModel) QAbstractItemModel_PTR() *QAbstractItemModel {
|
|
return p
|
|
}
|
|
|
|
func (p *QAbstractItemModel) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAbstractItemModel) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractItemModel(ptr QAbstractItemModel_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractItemModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractItemModelFromPointer(ptr unsafe.Pointer) *QAbstractItemModel {
|
|
var n = new(QAbstractItemModel)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAbstractItemModelFromPointer(ptr unsafe.Pointer) *QAbstractItemModel {
|
|
var n = NewQAbstractItemModelFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QAbstractItemModel_") {
|
|
n.SetObjectName("QAbstractItemModel_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_Sibling
|
|
func callbackQAbstractItemModel_Sibling(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractItemModel::sibling")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sibling"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQAbstractItemModelFromPointer(ptr).SiblingDefault(int(row), int(column), NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectSibling(f func(row int, column int, index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractItemModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sibling", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectSibling() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sibling")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) Sibling(row int, column int, index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractItemModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractItemModel_Sibling(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) SiblingDefault(row int, column int, index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractItemModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractItemModel_SiblingDefault(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractItemModel(parent QObject_ITF) *QAbstractItemModel {
|
|
defer qt.Recovering("QAbstractItemModel::QAbstractItemModel")
|
|
|
|
return newQAbstractItemModelFromPointer(C.QAbstractItemModel_NewQAbstractItemModel(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) BeginInsertColumns(parent QModelIndex_ITF, first int, last int) {
|
|
defer qt.Recovering("QAbstractItemModel::beginInsertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_BeginInsertColumns(ptr.Pointer(), PointerFromQModelIndex(parent), C.int(first), C.int(last))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) BeginInsertRows(parent QModelIndex_ITF, first int, last int) {
|
|
defer qt.Recovering("QAbstractItemModel::beginInsertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_BeginInsertRows(ptr.Pointer(), PointerFromQModelIndex(parent), C.int(first), C.int(last))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) BeginMoveColumns(sourceParent QModelIndex_ITF, sourceFirst int, sourceLast int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractItemModel::beginMoveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_BeginMoveColumns(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceFirst), C.int(sourceLast), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) BeginMoveRows(sourceParent QModelIndex_ITF, sourceFirst int, sourceLast int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractItemModel::beginMoveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_BeginMoveRows(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceFirst), C.int(sourceLast), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) BeginRemoveColumns(parent QModelIndex_ITF, first int, last int) {
|
|
defer qt.Recovering("QAbstractItemModel::beginRemoveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_BeginRemoveColumns(ptr.Pointer(), PointerFromQModelIndex(parent), C.int(first), C.int(last))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) BeginRemoveRows(parent QModelIndex_ITF, first int, last int) {
|
|
defer qt.Recovering("QAbstractItemModel::beginRemoveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_BeginRemoveRows(ptr.Pointer(), PointerFromQModelIndex(parent), C.int(first), C.int(last))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) BeginResetModel() {
|
|
defer qt.Recovering("QAbstractItemModel::beginResetModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_BeginResetModel(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_Buddy
|
|
func callbackQAbstractItemModel_Buddy(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractItemModel::buddy")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "buddy"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQAbstractItemModelFromPointer(ptr).BuddyDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectBuddy(f func(index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractItemModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "buddy", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectBuddy() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "buddy")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) Buddy(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractItemModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractItemModel_Buddy(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) BuddyDefault(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractItemModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractItemModel_BuddyDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_CanDropMimeData
|
|
func callbackQAbstractItemModel_CanDropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::canDropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canDropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).CanDropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectCanDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canDropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectCanDropMimeData() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canDropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) CanDropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_CanDropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) CanDropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_CanDropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_CanFetchMore
|
|
func callbackQAbstractItemModel_CanFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::canFetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canFetchMore"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).CanFetchMoreDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectCanFetchMore(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canFetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectCanFetchMore() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canFetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) CanFetchMore(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_CanFetchMore(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) CanFetchMoreDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_CanFetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ChangePersistentIndex(from QModelIndex_ITF, to QModelIndex_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::changePersistentIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ChangePersistentIndex(ptr.Pointer(), PointerFromQModelIndex(from), PointerFromQModelIndex(to))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_ColumnCount
|
|
func callbackQAbstractItemModel_ColumnCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::columnCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(0)
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectColumnCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QAbstractItemModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectColumnCount(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ColumnCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QAbstractItemModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractItemModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_ColumnsAboutToBeInserted
|
|
func callbackQAbstractItemModel_ColumnsAboutToBeInserted(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::columnsAboutToBeInserted")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnsAboutToBeInserted"); signal != nil {
|
|
signal.(func(*QModelIndex, int, int))(NewQModelIndexFromPointer(parent), int(first), int(last))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectColumnsAboutToBeInserted(f func(parent *QModelIndex, first int, last int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::columnsAboutToBeInserted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectColumnsAboutToBeInserted(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnsAboutToBeInserted", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectColumnsAboutToBeInserted() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::columnsAboutToBeInserted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectColumnsAboutToBeInserted(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnsAboutToBeInserted")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_ColumnsAboutToBeMoved
|
|
func callbackQAbstractItemModel_ColumnsAboutToBeMoved(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceStart C.int, sourceEnd C.int, destinationParent unsafe.Pointer, destinationColumn C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::columnsAboutToBeMoved")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnsAboutToBeMoved"); signal != nil {
|
|
signal.(func(*QModelIndex, int, int, *QModelIndex, int))(NewQModelIndexFromPointer(sourceParent), int(sourceStart), int(sourceEnd), NewQModelIndexFromPointer(destinationParent), int(destinationColumn))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectColumnsAboutToBeMoved(f func(sourceParent *QModelIndex, sourceStart int, sourceEnd int, destinationParent *QModelIndex, destinationColumn int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::columnsAboutToBeMoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectColumnsAboutToBeMoved(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnsAboutToBeMoved", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectColumnsAboutToBeMoved() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::columnsAboutToBeMoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectColumnsAboutToBeMoved(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnsAboutToBeMoved")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_ColumnsAboutToBeRemoved
|
|
func callbackQAbstractItemModel_ColumnsAboutToBeRemoved(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::columnsAboutToBeRemoved")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnsAboutToBeRemoved"); signal != nil {
|
|
signal.(func(*QModelIndex, int, int))(NewQModelIndexFromPointer(parent), int(first), int(last))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectColumnsAboutToBeRemoved(f func(parent *QModelIndex, first int, last int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::columnsAboutToBeRemoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectColumnsAboutToBeRemoved(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnsAboutToBeRemoved", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectColumnsAboutToBeRemoved() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::columnsAboutToBeRemoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectColumnsAboutToBeRemoved(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnsAboutToBeRemoved")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_ColumnsInserted
|
|
func callbackQAbstractItemModel_ColumnsInserted(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::columnsInserted")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnsInserted"); signal != nil {
|
|
signal.(func(*QModelIndex, int, int))(NewQModelIndexFromPointer(parent), int(first), int(last))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectColumnsInserted(f func(parent *QModelIndex, first int, last int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::columnsInserted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectColumnsInserted(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnsInserted", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectColumnsInserted() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::columnsInserted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectColumnsInserted(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnsInserted")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_ColumnsMoved
|
|
func callbackQAbstractItemModel_ColumnsMoved(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, start C.int, end C.int, destination unsafe.Pointer, column C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::columnsMoved")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnsMoved"); signal != nil {
|
|
signal.(func(*QModelIndex, int, int, *QModelIndex, int))(NewQModelIndexFromPointer(parent), int(start), int(end), NewQModelIndexFromPointer(destination), int(column))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectColumnsMoved(f func(parent *QModelIndex, start int, end int, destination *QModelIndex, column int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::columnsMoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectColumnsMoved(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnsMoved", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectColumnsMoved() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::columnsMoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectColumnsMoved(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnsMoved")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_ColumnsRemoved
|
|
func callbackQAbstractItemModel_ColumnsRemoved(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::columnsRemoved")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnsRemoved"); signal != nil {
|
|
signal.(func(*QModelIndex, int, int))(NewQModelIndexFromPointer(parent), int(first), int(last))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectColumnsRemoved(f func(parent *QModelIndex, first int, last int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::columnsRemoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectColumnsRemoved(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnsRemoved", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectColumnsRemoved() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::columnsRemoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectColumnsRemoved(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnsRemoved")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) CreateIndex(row int, column int, p unsafe.Pointer) *QModelIndex {
|
|
defer qt.Recovering("QAbstractItemModel::createIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractItemModel_CreateIndex(ptr.Pointer(), C.int(row), C.int(column), p))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_Data
|
|
func callbackQAbstractItemModel_Data(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractItemModel::data")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "data"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(*QModelIndex, int) *QVariant)(NewQModelIndexFromPointer(index), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(nil)
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectData(f func(index *QModelIndex, role int) *QVariant) {
|
|
defer qt.Recovering("connect QAbstractItemModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "data", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectData(index QModelIndex_ITF, role int) {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "data")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) Data(index QModelIndex_ITF, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractItemModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractItemModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_DropMimeData
|
|
func callbackQAbstractItemModel_DropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::dropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "dropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).DropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "dropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectDropMimeData() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "dropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_DropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) EndInsertColumns() {
|
|
defer qt.Recovering("QAbstractItemModel::endInsertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_EndInsertColumns(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) EndInsertRows() {
|
|
defer qt.Recovering("QAbstractItemModel::endInsertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_EndInsertRows(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) EndMoveColumns() {
|
|
defer qt.Recovering("QAbstractItemModel::endMoveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_EndMoveColumns(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) EndMoveRows() {
|
|
defer qt.Recovering("QAbstractItemModel::endMoveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_EndMoveRows(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) EndRemoveColumns() {
|
|
defer qt.Recovering("QAbstractItemModel::endRemoveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_EndRemoveColumns(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) EndRemoveRows() {
|
|
defer qt.Recovering("QAbstractItemModel::endRemoveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_EndRemoveRows(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) EndResetModel() {
|
|
defer qt.Recovering("QAbstractItemModel::endResetModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_EndResetModel(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_FetchMore
|
|
func callbackQAbstractItemModel_FetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractItemModel::fetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
|
|
signal.(func(*QModelIndex))(NewQModelIndexFromPointer(parent))
|
|
} else {
|
|
NewQAbstractItemModelFromPointer(ptr).FetchMoreDefault(NewQModelIndexFromPointer(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectFetchMore(f func(parent *QModelIndex)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectFetchMore() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) FetchMore(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_FetchMore(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) FetchMoreDefault(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_FetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_Flags
|
|
func callbackQAbstractItemModel_Flags(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::flags")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "flags"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) Qt__ItemFlag)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return C.int(NewQAbstractItemModelFromPointer(ptr).FlagsDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectFlags(f func(index *QModelIndex) Qt__ItemFlag) {
|
|
defer qt.Recovering("connect QAbstractItemModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "flags", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectFlags() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "flags")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QAbstractItemModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QAbstractItemModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) FlagsDefault(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QAbstractItemModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QAbstractItemModel_FlagsDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_HasChildren
|
|
func callbackQAbstractItemModel_HasChildren(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::hasChildren")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "hasChildren"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).HasChildrenDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectHasChildren(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "hasChildren", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectHasChildren() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "hasChildren")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) HasChildren(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_HasChildren(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) HasChildrenDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_HasChildrenDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) HasIndex(row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::hasIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_HasIndex(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_HeaderData
|
|
func callbackQAbstractItemModel_HeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractItemModel::headerData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "headerData"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(int, Qt__Orientation, int) *QVariant)(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQAbstractItemModelFromPointer(ptr).HeaderDataDefault(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectHeaderData(f func(section int, orientation Qt__Orientation, role int) *QVariant) {
|
|
defer qt.Recovering("connect QAbstractItemModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "headerData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectHeaderData() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "headerData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) HeaderData(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractItemModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractItemModel_HeaderData(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) HeaderDataDefault(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractItemModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractItemModel_HeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_HeaderDataChanged
|
|
func callbackQAbstractItemModel_HeaderDataChanged(ptr unsafe.Pointer, ptrName *C.char, orientation C.int, first C.int, last C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::headerDataChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "headerDataChanged"); signal != nil {
|
|
signal.(func(Qt__Orientation, int, int))(Qt__Orientation(orientation), int(first), int(last))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectHeaderDataChanged(f func(orientation Qt__Orientation, first int, last int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::headerDataChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectHeaderDataChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "headerDataChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectHeaderDataChanged() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::headerDataChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectHeaderDataChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "headerDataChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) HeaderDataChanged(orientation Qt__Orientation, first int, last int) {
|
|
defer qt.Recovering("QAbstractItemModel::headerDataChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_HeaderDataChanged(ptr.Pointer(), C.int(orientation), C.int(first), C.int(last))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_Index
|
|
func callbackQAbstractItemModel_Index(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractItemModel::index")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "index"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(nil)
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractItemModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "index", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectIndex(row int, column int, parent QModelIndex_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "index")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractItemModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractItemModel_Index(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) InsertColumn(column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::insertColumn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_InsertColumn(ptr.Pointer(), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_InsertColumns
|
|
func callbackQAbstractItemModel_InsertColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::insertColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).InsertColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectInsertColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectInsertColumns() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) InsertColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_InsertColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) InsertColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_InsertColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) InsertRow(row int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::insertRow")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_InsertRow(ptr.Pointer(), C.int(row), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_InsertRows
|
|
func callbackQAbstractItemModel_InsertRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::insertRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).InsertRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectInsertRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectInsertRows() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) InsertRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_InsertRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) InsertRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_InsertRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_MimeTypes
|
|
func callbackQAbstractItemModel_MimeTypes(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QAbstractItemModel::mimeTypes")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mimeTypes"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(NewQAbstractItemModelFromPointer(ptr).MimeTypesDefault(), "|"))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectMimeTypes(f func() []string) {
|
|
defer qt.Recovering("connect QAbstractItemModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mimeTypes", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectMimeTypes() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mimeTypes")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) MimeTypes() []string {
|
|
defer qt.Recovering("QAbstractItemModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QAbstractItemModel_MimeTypes(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) MimeTypesDefault() []string {
|
|
defer qt.Recovering("QAbstractItemModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QAbstractItemModel_MimeTypesDefault(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_ModelAboutToBeReset
|
|
func callbackQAbstractItemModel_ModelAboutToBeReset(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractItemModel::modelAboutToBeReset")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "modelAboutToBeReset"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectModelAboutToBeReset(f func()) {
|
|
defer qt.Recovering("connect QAbstractItemModel::modelAboutToBeReset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectModelAboutToBeReset(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "modelAboutToBeReset", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectModelAboutToBeReset() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::modelAboutToBeReset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectModelAboutToBeReset(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "modelAboutToBeReset")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_ModelReset
|
|
func callbackQAbstractItemModel_ModelReset(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractItemModel::modelReset")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "modelReset"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectModelReset(f func()) {
|
|
defer qt.Recovering("connect QAbstractItemModel::modelReset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectModelReset(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "modelReset", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectModelReset() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::modelReset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectModelReset(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "modelReset")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) MoveColumn(sourceParent QModelIndex_ITF, sourceColumn int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractItemModel::moveColumn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_MoveColumn(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_MoveColumns
|
|
func callbackQAbstractItemModel_MoveColumns(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceColumn C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::moveColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).MoveColumnsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectMoveColumns(f func(sourceParent *QModelIndex, sourceColumn int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectMoveColumns() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) MoveColumns(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractItemModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_MoveColumns(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) MoveColumnsDefault(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractItemModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_MoveColumnsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) MoveRow(sourceParent QModelIndex_ITF, sourceRow int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractItemModel::moveRow")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_MoveRow(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_MoveRows
|
|
func callbackQAbstractItemModel_MoveRows(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceRow C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::moveRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).MoveRowsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectMoveRows(f func(sourceParent *QModelIndex, sourceRow int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectMoveRows() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) MoveRows(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractItemModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_MoveRows(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) MoveRowsDefault(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractItemModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_MoveRowsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_Parent
|
|
func callbackQAbstractItemModel_Parent(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractItemModel::parent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "parent"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(nil)
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectParent(f func(index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractItemModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "parent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectParent(index QModelIndex_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "parent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) Parent(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractItemModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractItemModel_Parent(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) RemoveColumn(column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::removeColumn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_RemoveColumn(ptr.Pointer(), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_RemoveColumns
|
|
func callbackQAbstractItemModel_RemoveColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::removeColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).RemoveColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectRemoveColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectRemoveColumns() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) RemoveColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_RemoveColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) RemoveColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_RemoveColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) RemoveRow(row int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::removeRow")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_RemoveRow(ptr.Pointer(), C.int(row), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_RemoveRows
|
|
func callbackQAbstractItemModel_RemoveRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::removeRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).RemoveRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectRemoveRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectRemoveRows() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) RemoveRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_RemoveRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) RemoveRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_RemoveRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_ResetInternalData
|
|
func callbackQAbstractItemModel_ResetInternalData(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractItemModel::resetInternalData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resetInternalData"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectResetInternalData(f func()) {
|
|
defer qt.Recovering("connect QAbstractItemModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resetInternalData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectResetInternalData() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resetInternalData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ResetInternalData() {
|
|
defer qt.Recovering("QAbstractItemModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ResetInternalData(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_Revert
|
|
func callbackQAbstractItemModel_Revert(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractItemModel::revert")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractItemModelFromPointer(ptr).RevertDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectRevert(f func()) {
|
|
defer qt.Recovering("connect QAbstractItemModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "revert", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectRevert() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "revert")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) Revert() {
|
|
defer qt.Recovering("QAbstractItemModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_Revert(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) RevertDefault() {
|
|
defer qt.Recovering("QAbstractItemModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_RevertDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_RowCount
|
|
func callbackQAbstractItemModel_RowCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::rowCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(0)
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectRowCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QAbstractItemModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectRowCount(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) RowCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QAbstractItemModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractItemModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_RowsAboutToBeInserted
|
|
func callbackQAbstractItemModel_RowsAboutToBeInserted(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, start C.int, end C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::rowsAboutToBeInserted")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowsAboutToBeInserted"); signal != nil {
|
|
signal.(func(*QModelIndex, int, int))(NewQModelIndexFromPointer(parent), int(start), int(end))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectRowsAboutToBeInserted(f func(parent *QModelIndex, start int, end int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::rowsAboutToBeInserted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectRowsAboutToBeInserted(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowsAboutToBeInserted", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectRowsAboutToBeInserted() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::rowsAboutToBeInserted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectRowsAboutToBeInserted(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowsAboutToBeInserted")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_RowsAboutToBeMoved
|
|
func callbackQAbstractItemModel_RowsAboutToBeMoved(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceStart C.int, sourceEnd C.int, destinationParent unsafe.Pointer, destinationRow C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::rowsAboutToBeMoved")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowsAboutToBeMoved"); signal != nil {
|
|
signal.(func(*QModelIndex, int, int, *QModelIndex, int))(NewQModelIndexFromPointer(sourceParent), int(sourceStart), int(sourceEnd), NewQModelIndexFromPointer(destinationParent), int(destinationRow))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectRowsAboutToBeMoved(f func(sourceParent *QModelIndex, sourceStart int, sourceEnd int, destinationParent *QModelIndex, destinationRow int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::rowsAboutToBeMoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectRowsAboutToBeMoved(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowsAboutToBeMoved", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectRowsAboutToBeMoved() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::rowsAboutToBeMoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectRowsAboutToBeMoved(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowsAboutToBeMoved")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_RowsAboutToBeRemoved
|
|
func callbackQAbstractItemModel_RowsAboutToBeRemoved(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::rowsAboutToBeRemoved")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowsAboutToBeRemoved"); signal != nil {
|
|
signal.(func(*QModelIndex, int, int))(NewQModelIndexFromPointer(parent), int(first), int(last))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectRowsAboutToBeRemoved(f func(parent *QModelIndex, first int, last int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::rowsAboutToBeRemoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectRowsAboutToBeRemoved(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowsAboutToBeRemoved", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectRowsAboutToBeRemoved() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::rowsAboutToBeRemoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectRowsAboutToBeRemoved(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowsAboutToBeRemoved")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_RowsInserted
|
|
func callbackQAbstractItemModel_RowsInserted(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::rowsInserted")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowsInserted"); signal != nil {
|
|
signal.(func(*QModelIndex, int, int))(NewQModelIndexFromPointer(parent), int(first), int(last))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectRowsInserted(f func(parent *QModelIndex, first int, last int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::rowsInserted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectRowsInserted(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowsInserted", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectRowsInserted() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::rowsInserted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectRowsInserted(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowsInserted")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_RowsMoved
|
|
func callbackQAbstractItemModel_RowsMoved(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, start C.int, end C.int, destination unsafe.Pointer, row C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::rowsMoved")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowsMoved"); signal != nil {
|
|
signal.(func(*QModelIndex, int, int, *QModelIndex, int))(NewQModelIndexFromPointer(parent), int(start), int(end), NewQModelIndexFromPointer(destination), int(row))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectRowsMoved(f func(parent *QModelIndex, start int, end int, destination *QModelIndex, row int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::rowsMoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectRowsMoved(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowsMoved", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectRowsMoved() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::rowsMoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectRowsMoved(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowsMoved")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_RowsRemoved
|
|
func callbackQAbstractItemModel_RowsRemoved(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer, first C.int, last C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::rowsRemoved")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowsRemoved"); signal != nil {
|
|
signal.(func(*QModelIndex, int, int))(NewQModelIndexFromPointer(parent), int(first), int(last))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectRowsRemoved(f func(parent *QModelIndex, first int, last int)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::rowsRemoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectRowsRemoved(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowsRemoved", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectRowsRemoved() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::rowsRemoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectRowsRemoved(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowsRemoved")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_SetData
|
|
func callbackQAbstractItemModel_SetData(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::setData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, *QVariant, int) bool)(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).SetDataDefault(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectSetData(f func(index *QModelIndex, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectSetData() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) SetData(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractItemModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_SetData(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) SetDataDefault(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractItemModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_SetDataDefault(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_SetHeaderData
|
|
func callbackQAbstractItemModel_SetHeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::setHeaderData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setHeaderData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, Qt__Orientation, *QVariant, int) bool)(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).SetHeaderDataDefault(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectSetHeaderData(f func(section int, orientation Qt__Orientation, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setHeaderData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectSetHeaderData() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setHeaderData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) SetHeaderData(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractItemModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_SetHeaderData(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) SetHeaderDataDefault(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractItemModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_SetHeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_Sort
|
|
func callbackQAbstractItemModel_Sort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
|
|
defer qt.Recovering("callback QAbstractItemModel::sort")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
|
|
signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
|
|
} else {
|
|
NewQAbstractItemModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sort", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectSort() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sort")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) Sort(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QAbstractItemModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) SortDefault(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QAbstractItemModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_Span
|
|
func callbackQAbstractItemModel_Span(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractItemModel::span")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "span"); signal != nil {
|
|
return PointerFromQSize(signal.(func(*QModelIndex) *QSize)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQSize(NewQAbstractItemModelFromPointer(ptr).SpanDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectSpan(f func(index *QModelIndex) *QSize) {
|
|
defer qt.Recovering("connect QAbstractItemModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "span", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectSpan() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "span")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) Span(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QAbstractItemModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QAbstractItemModel_Span(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) SpanDefault(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QAbstractItemModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QAbstractItemModel_SpanDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_Submit
|
|
func callbackQAbstractItemModel_Submit(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::submit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "submit"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).SubmitDefault()))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectSubmit(f func() bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "submit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectSubmit() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "submit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) Submit() bool {
|
|
defer qt.Recovering("QAbstractItemModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_Submit(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) SubmitDefault() bool {
|
|
defer qt.Recovering("QAbstractItemModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_SubmitDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_SupportedDragActions
|
|
func callbackQAbstractItemModel_SupportedDragActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::supportedDragActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDragActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQAbstractItemModelFromPointer(ptr).SupportedDragActionsDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectSupportedDragActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QAbstractItemModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDragActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectSupportedDragActions() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDragActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) SupportedDragActions() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractItemModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractItemModel_SupportedDragActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) SupportedDragActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractItemModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractItemModel_SupportedDragActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_SupportedDropActions
|
|
func callbackQAbstractItemModel_SupportedDropActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::supportedDropActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDropActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQAbstractItemModelFromPointer(ptr).SupportedDropActionsDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectSupportedDropActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QAbstractItemModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDropActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectSupportedDropActions() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDropActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) SupportedDropActions() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractItemModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractItemModel_SupportedDropActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) SupportedDropActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractItemModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractItemModel_SupportedDropActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DestroyQAbstractItemModel() {
|
|
defer qt.Recovering("QAbstractItemModel::~QAbstractItemModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractItemModel_DestroyQAbstractItemModel(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_TimerEvent
|
|
func callbackQAbstractItemModel_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractItemModel::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractItemModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_ChildEvent
|
|
func callbackQAbstractItemModel_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractItemModel::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractItemModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_ConnectNotify
|
|
func callbackQAbstractItemModel_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractItemModel::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractItemModelFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_CustomEvent
|
|
func callbackQAbstractItemModel_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractItemModel::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractItemModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_DeleteLater
|
|
func callbackQAbstractItemModel_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractItemModel::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractItemModelFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QAbstractItemModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DeleteLater() {
|
|
defer qt.Recovering("QAbstractItemModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractItemModel_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DeleteLaterDefault() {
|
|
defer qt.Recovering("QAbstractItemModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractItemModel_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_DisconnectNotify
|
|
func callbackQAbstractItemModel_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractItemModel::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractItemModelFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractItemModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractItemModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractItemModel_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_Event
|
|
func callbackQAbstractItemModel_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_EventFilter
|
|
func callbackQAbstractItemModel_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractItemModel::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractItemModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractItemModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractItemModel_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractItemModel_MetaObject
|
|
func callbackQAbstractItemModel_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractItemModel::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQAbstractItemModelFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QAbstractItemModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QAbstractItemModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QAbstractItemModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractItemModel_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractItemModel) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QAbstractItemModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractItemModel_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAbstractListModel struct {
|
|
QAbstractItemModel
|
|
}
|
|
|
|
type QAbstractListModel_ITF interface {
|
|
QAbstractItemModel_ITF
|
|
QAbstractListModel_PTR() *QAbstractListModel
|
|
}
|
|
|
|
func (p *QAbstractListModel) QAbstractListModel_PTR() *QAbstractListModel {
|
|
return p
|
|
}
|
|
|
|
func (p *QAbstractListModel) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractItemModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAbstractListModel) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractItemModel_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractListModel(ptr QAbstractListModel_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractListModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractListModelFromPointer(ptr unsafe.Pointer) *QAbstractListModel {
|
|
var n = new(QAbstractListModel)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAbstractListModelFromPointer(ptr unsafe.Pointer) *QAbstractListModel {
|
|
var n = NewQAbstractListModelFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QAbstractListModel_") {
|
|
n.SetObjectName("QAbstractListModel_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
//export callbackQAbstractListModel_Index
|
|
func callbackQAbstractListModel_Index(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractListModel::index")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "index"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQAbstractListModelFromPointer(ptr).IndexDefault(int(row), int(column), NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractListModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "index", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectIndex() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "index")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractListModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractListModel_Index(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) IndexDefault(row int, column int, parent QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractListModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractListModel_IndexDefault(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractListModel(parent QObject_ITF) *QAbstractListModel {
|
|
defer qt.Recovering("QAbstractListModel::QAbstractListModel")
|
|
|
|
return newQAbstractListModelFromPointer(C.QAbstractListModel_NewQAbstractListModel(PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQAbstractListModel_DropMimeData
|
|
func callbackQAbstractListModel_DropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::dropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "dropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).DropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "dropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectDropMimeData() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "dropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_DropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_Flags
|
|
func callbackQAbstractListModel_Flags(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::flags")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "flags"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) Qt__ItemFlag)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return C.int(NewQAbstractListModelFromPointer(ptr).FlagsDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectFlags(f func(index *QModelIndex) Qt__ItemFlag) {
|
|
defer qt.Recovering("connect QAbstractListModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "flags", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectFlags() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "flags")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QAbstractListModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QAbstractListModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) FlagsDefault(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QAbstractListModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QAbstractListModel_FlagsDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractListModel_Sibling
|
|
func callbackQAbstractListModel_Sibling(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, idx unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractListModel::sibling")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sibling"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(idx)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQAbstractListModelFromPointer(ptr).SiblingDefault(int(row), int(column), NewQModelIndexFromPointer(idx)))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectSibling(f func(row int, column int, idx *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractListModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sibling", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectSibling() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sibling")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) Sibling(row int, column int, idx QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractListModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractListModel_Sibling(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) SiblingDefault(row int, column int, idx QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractListModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractListModel_SiblingDefault(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DestroyQAbstractListModel() {
|
|
defer qt.Recovering("QAbstractListModel::~QAbstractListModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractListModel_DestroyQAbstractListModel(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractListModel_Buddy
|
|
func callbackQAbstractListModel_Buddy(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractListModel::buddy")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "buddy"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQAbstractListModelFromPointer(ptr).BuddyDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectBuddy(f func(index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractListModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "buddy", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectBuddy() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "buddy")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) Buddy(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractListModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractListModel_Buddy(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) BuddyDefault(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractListModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractListModel_BuddyDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractListModel_CanDropMimeData
|
|
func callbackQAbstractListModel_CanDropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::canDropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canDropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).CanDropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectCanDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canDropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectCanDropMimeData() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canDropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) CanDropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_CanDropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) CanDropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_CanDropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_CanFetchMore
|
|
func callbackQAbstractListModel_CanFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::canFetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canFetchMore"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).CanFetchMoreDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectCanFetchMore(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canFetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectCanFetchMore() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canFetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) CanFetchMore(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_CanFetchMore(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) CanFetchMoreDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_CanFetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_ColumnCount
|
|
func callbackQAbstractListModel_ColumnCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::columnCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(NewQAbstractListModelFromPointer(ptr).ColumnCountDefault(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectColumnCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QAbstractListModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectColumnCount() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ColumnCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QAbstractListModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractListModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ColumnCountDefault(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QAbstractListModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractListModel_ColumnCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractListModel_Data
|
|
func callbackQAbstractListModel_Data(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractListModel::data")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "data"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(*QModelIndex, int) *QVariant)(NewQModelIndexFromPointer(index), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(nil)
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectData(f func(index *QModelIndex, role int) *QVariant) {
|
|
defer qt.Recovering("connect QAbstractListModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "data", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectData() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "data")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) Data(index QModelIndex_ITF, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractListModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractListModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractListModel_FetchMore
|
|
func callbackQAbstractListModel_FetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractListModel::fetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
|
|
signal.(func(*QModelIndex))(NewQModelIndexFromPointer(parent))
|
|
} else {
|
|
NewQAbstractListModelFromPointer(ptr).FetchMoreDefault(NewQModelIndexFromPointer(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectFetchMore(f func(parent *QModelIndex)) {
|
|
defer qt.Recovering("connect QAbstractListModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectFetchMore() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) FetchMore(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QAbstractListModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_FetchMore(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) FetchMoreDefault(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QAbstractListModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_FetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractListModel_HasChildren
|
|
func callbackQAbstractListModel_HasChildren(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::hasChildren")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "hasChildren"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).HasChildrenDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectHasChildren(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "hasChildren", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectHasChildren() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "hasChildren")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) HasChildren(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_HasChildren(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) HasChildrenDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_HasChildrenDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_HeaderData
|
|
func callbackQAbstractListModel_HeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractListModel::headerData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "headerData"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(int, Qt__Orientation, int) *QVariant)(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQAbstractListModelFromPointer(ptr).HeaderDataDefault(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectHeaderData(f func(section int, orientation Qt__Orientation, role int) *QVariant) {
|
|
defer qt.Recovering("connect QAbstractListModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "headerData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectHeaderData() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "headerData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) HeaderData(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractListModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractListModel_HeaderData(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) HeaderDataDefault(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractListModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractListModel_HeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractListModel_InsertColumns
|
|
func callbackQAbstractListModel_InsertColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::insertColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).InsertColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectInsertColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectInsertColumns() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) InsertColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_InsertColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) InsertColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_InsertColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_InsertRows
|
|
func callbackQAbstractListModel_InsertRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::insertRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).InsertRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectInsertRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectInsertRows() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) InsertRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_InsertRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) InsertRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_InsertRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_MimeTypes
|
|
func callbackQAbstractListModel_MimeTypes(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QAbstractListModel::mimeTypes")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mimeTypes"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(NewQAbstractListModelFromPointer(ptr).MimeTypesDefault(), "|"))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectMimeTypes(f func() []string) {
|
|
defer qt.Recovering("connect QAbstractListModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mimeTypes", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectMimeTypes() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mimeTypes")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) MimeTypes() []string {
|
|
defer qt.Recovering("QAbstractListModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QAbstractListModel_MimeTypes(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) MimeTypesDefault() []string {
|
|
defer qt.Recovering("QAbstractListModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QAbstractListModel_MimeTypesDefault(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQAbstractListModel_MoveColumns
|
|
func callbackQAbstractListModel_MoveColumns(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceColumn C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::moveColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).MoveColumnsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectMoveColumns(f func(sourceParent *QModelIndex, sourceColumn int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectMoveColumns() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) MoveColumns(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractListModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_MoveColumns(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) MoveColumnsDefault(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractListModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_MoveColumnsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_MoveRows
|
|
func callbackQAbstractListModel_MoveRows(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceRow C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::moveRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).MoveRowsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectMoveRows(f func(sourceParent *QModelIndex, sourceRow int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectMoveRows() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) MoveRows(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractListModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_MoveRows(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) MoveRowsDefault(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractListModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_MoveRowsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_Parent
|
|
func callbackQAbstractListModel_Parent(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractListModel::parent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "parent"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQAbstractListModelFromPointer(ptr).ParentDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectParent(f func(index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractListModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "parent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectParent() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "parent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) Parent(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractListModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractListModel_Parent(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ParentDefault(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractListModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractListModel_ParentDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractListModel_RemoveColumns
|
|
func callbackQAbstractListModel_RemoveColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::removeColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).RemoveColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectRemoveColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectRemoveColumns() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) RemoveColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_RemoveColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) RemoveColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_RemoveColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_RemoveRows
|
|
func callbackQAbstractListModel_RemoveRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::removeRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).RemoveRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectRemoveRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectRemoveRows() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) RemoveRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_RemoveRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) RemoveRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_RemoveRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_ResetInternalData
|
|
func callbackQAbstractListModel_ResetInternalData(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractListModel::resetInternalData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resetInternalData"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractListModelFromPointer(ptr).ResetInternalDataDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectResetInternalData(f func()) {
|
|
defer qt.Recovering("connect QAbstractListModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resetInternalData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectResetInternalData() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resetInternalData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ResetInternalData() {
|
|
defer qt.Recovering("QAbstractListModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_ResetInternalData(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ResetInternalDataDefault() {
|
|
defer qt.Recovering("QAbstractListModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_ResetInternalDataDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractListModel_Revert
|
|
func callbackQAbstractListModel_Revert(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractListModel::revert")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractListModelFromPointer(ptr).RevertDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectRevert(f func()) {
|
|
defer qt.Recovering("connect QAbstractListModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "revert", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectRevert() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "revert")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) Revert() {
|
|
defer qt.Recovering("QAbstractListModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_Revert(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) RevertDefault() {
|
|
defer qt.Recovering("QAbstractListModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_RevertDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractListModel_RowCount
|
|
func callbackQAbstractListModel_RowCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::rowCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(0)
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectRowCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QAbstractListModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectRowCount() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) RowCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QAbstractListModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractListModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractListModel_SetData
|
|
func callbackQAbstractListModel_SetData(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::setData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, *QVariant, int) bool)(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).SetDataDefault(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectSetData(f func(index *QModelIndex, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectSetData() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) SetData(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractListModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_SetData(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) SetDataDefault(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractListModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_SetDataDefault(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_SetHeaderData
|
|
func callbackQAbstractListModel_SetHeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::setHeaderData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setHeaderData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, Qt__Orientation, *QVariant, int) bool)(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).SetHeaderDataDefault(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectSetHeaderData(f func(section int, orientation Qt__Orientation, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setHeaderData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectSetHeaderData() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setHeaderData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) SetHeaderData(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractListModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_SetHeaderData(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) SetHeaderDataDefault(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractListModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_SetHeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_Sort
|
|
func callbackQAbstractListModel_Sort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
|
|
defer qt.Recovering("callback QAbstractListModel::sort")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
|
|
signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
|
|
} else {
|
|
NewQAbstractListModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
|
|
defer qt.Recovering("connect QAbstractListModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sort", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectSort() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sort")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) Sort(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QAbstractListModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) SortDefault(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QAbstractListModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractListModel_Span
|
|
func callbackQAbstractListModel_Span(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractListModel::span")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "span"); signal != nil {
|
|
return PointerFromQSize(signal.(func(*QModelIndex) *QSize)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQSize(NewQAbstractListModelFromPointer(ptr).SpanDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectSpan(f func(index *QModelIndex) *QSize) {
|
|
defer qt.Recovering("connect QAbstractListModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "span", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectSpan() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "span")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) Span(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QAbstractListModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QAbstractListModel_Span(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) SpanDefault(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QAbstractListModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QAbstractListModel_SpanDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractListModel_Submit
|
|
func callbackQAbstractListModel_Submit(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::submit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "submit"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).SubmitDefault()))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectSubmit(f func() bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "submit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectSubmit() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "submit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) Submit() bool {
|
|
defer qt.Recovering("QAbstractListModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_Submit(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) SubmitDefault() bool {
|
|
defer qt.Recovering("QAbstractListModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_SubmitDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_SupportedDragActions
|
|
func callbackQAbstractListModel_SupportedDragActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::supportedDragActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDragActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQAbstractListModelFromPointer(ptr).SupportedDragActionsDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectSupportedDragActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QAbstractListModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDragActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectSupportedDragActions() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDragActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) SupportedDragActions() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractListModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractListModel_SupportedDragActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) SupportedDragActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractListModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractListModel_SupportedDragActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractListModel_SupportedDropActions
|
|
func callbackQAbstractListModel_SupportedDropActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::supportedDropActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDropActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQAbstractListModelFromPointer(ptr).SupportedDropActionsDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectSupportedDropActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QAbstractListModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDropActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectSupportedDropActions() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDropActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) SupportedDropActions() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractListModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractListModel_SupportedDropActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) SupportedDropActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractListModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractListModel_SupportedDropActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractListModel_TimerEvent
|
|
func callbackQAbstractListModel_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractListModel::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractListModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QAbstractListModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractListModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractListModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractListModel_ChildEvent
|
|
func callbackQAbstractListModel_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractListModel::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractListModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QAbstractListModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractListModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractListModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractListModel_ConnectNotify
|
|
func callbackQAbstractListModel_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractListModel::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractListModelFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractListModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractListModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractListModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractListModel_CustomEvent
|
|
func callbackQAbstractListModel_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractListModel::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractListModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QAbstractListModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractListModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractListModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractListModel_DeleteLater
|
|
func callbackQAbstractListModel_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractListModel::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractListModelFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QAbstractListModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DeleteLater() {
|
|
defer qt.Recovering("QAbstractListModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractListModel_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DeleteLaterDefault() {
|
|
defer qt.Recovering("QAbstractListModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractListModel_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractListModel_DisconnectNotify
|
|
func callbackQAbstractListModel_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractListModel::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractListModelFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractListModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractListModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractListModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractListModel_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractListModel_Event
|
|
func callbackQAbstractListModel_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_EventFilter
|
|
func callbackQAbstractListModel_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractListModel::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractListModelFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractListModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractListModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractListModel_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractListModel_MetaObject
|
|
func callbackQAbstractListModel_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractListModel::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQAbstractListModelFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QAbstractListModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QAbstractListModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QAbstractListModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractListModel_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractListModel) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QAbstractListModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractListModel_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAbstractNativeEventFilter struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAbstractNativeEventFilter_ITF interface {
|
|
QAbstractNativeEventFilter_PTR() *QAbstractNativeEventFilter
|
|
}
|
|
|
|
func (p *QAbstractNativeEventFilter) QAbstractNativeEventFilter_PTR() *QAbstractNativeEventFilter {
|
|
return p
|
|
}
|
|
|
|
func (p *QAbstractNativeEventFilter) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAbstractNativeEventFilter) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractNativeEventFilter(ptr QAbstractNativeEventFilter_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractNativeEventFilter_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractNativeEventFilterFromPointer(ptr unsafe.Pointer) *QAbstractNativeEventFilter {
|
|
var n = new(QAbstractNativeEventFilter)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAbstractNativeEventFilterFromPointer(ptr unsafe.Pointer) *QAbstractNativeEventFilter {
|
|
var n = NewQAbstractNativeEventFilterFromPointer(ptr)
|
|
for len(n.ObjectNameAbs()) < len("QAbstractNativeEventFilter_") {
|
|
n.SetObjectNameAbs("QAbstractNativeEventFilter_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQAbstractNativeEventFilter() *QAbstractNativeEventFilter {
|
|
defer qt.Recovering("QAbstractNativeEventFilter::QAbstractNativeEventFilter")
|
|
|
|
return newQAbstractNativeEventFilterFromPointer(C.QAbstractNativeEventFilter_NewQAbstractNativeEventFilter())
|
|
}
|
|
|
|
//export callbackQAbstractNativeEventFilter_NativeEventFilter
|
|
func callbackQAbstractNativeEventFilter_NativeEventFilter(ptr unsafe.Pointer, ptrName *C.char, eventType *C.char, message unsafe.Pointer, result C.long) C.int {
|
|
defer qt.Recovering("callback QAbstractNativeEventFilter::nativeEventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "nativeEventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(string, unsafe.Pointer, int) bool)(C.GoString(eventType), message, int(result))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(false))
|
|
}
|
|
|
|
func (ptr *QAbstractNativeEventFilter) ConnectNativeEventFilter(f func(eventType string, message unsafe.Pointer, result int) bool) {
|
|
defer qt.Recovering("connect QAbstractNativeEventFilter::nativeEventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectNameAbs(), "nativeEventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractNativeEventFilter) DisconnectNativeEventFilter(eventType string, message unsafe.Pointer, result int) {
|
|
defer qt.Recovering("disconnect QAbstractNativeEventFilter::nativeEventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectNameAbs(), "nativeEventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractNativeEventFilter) NativeEventFilter(eventType string, message unsafe.Pointer, result int) bool {
|
|
defer qt.Recovering("QAbstractNativeEventFilter::nativeEventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractNativeEventFilter_NativeEventFilter(ptr.Pointer(), C.CString(eventType), message, C.long(result)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractNativeEventFilter) DestroyQAbstractNativeEventFilter() {
|
|
defer qt.Recovering("QAbstractNativeEventFilter::~QAbstractNativeEventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectNameAbs())
|
|
C.QAbstractNativeEventFilter_DestroyQAbstractNativeEventFilter(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractNativeEventFilter) ObjectNameAbs() string {
|
|
defer qt.Recovering("QAbstractNativeEventFilter::objectNameAbs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QAbstractNativeEventFilter_ObjectNameAbs(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAbstractNativeEventFilter) SetObjectNameAbs(name string) {
|
|
defer qt.Recovering("QAbstractNativeEventFilter::setObjectNameAbs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractNativeEventFilter_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
|
|
}
|
|
}
|
|
|
|
type QAbstractProxyModel struct {
|
|
QAbstractItemModel
|
|
}
|
|
|
|
type QAbstractProxyModel_ITF interface {
|
|
QAbstractItemModel_ITF
|
|
QAbstractProxyModel_PTR() *QAbstractProxyModel
|
|
}
|
|
|
|
func (p *QAbstractProxyModel) QAbstractProxyModel_PTR() *QAbstractProxyModel {
|
|
return p
|
|
}
|
|
|
|
func (p *QAbstractProxyModel) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractItemModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAbstractProxyModel) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractItemModel_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractProxyModel(ptr QAbstractProxyModel_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractProxyModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractProxyModelFromPointer(ptr unsafe.Pointer) *QAbstractProxyModel {
|
|
var n = new(QAbstractProxyModel)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAbstractProxyModelFromPointer(ptr unsafe.Pointer) *QAbstractProxyModel {
|
|
var n = NewQAbstractProxyModelFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QAbstractProxyModel_") {
|
|
n.SetObjectName("QAbstractProxyModel_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQAbstractProxyModel(parent QObject_ITF) *QAbstractProxyModel {
|
|
defer qt.Recovering("QAbstractProxyModel::QAbstractProxyModel")
|
|
|
|
return newQAbstractProxyModelFromPointer(C.QAbstractProxyModel_NewQAbstractProxyModel(PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_Buddy
|
|
func callbackQAbstractProxyModel_Buddy(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractProxyModel::buddy")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "buddy"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQAbstractProxyModelFromPointer(ptr).BuddyDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectBuddy(f func(index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "buddy", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectBuddy() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "buddy")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) Buddy(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractProxyModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractProxyModel_Buddy(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) BuddyDefault(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractProxyModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractProxyModel_BuddyDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_CanDropMimeData
|
|
func callbackQAbstractProxyModel_CanDropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::canDropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canDropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).CanDropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectCanDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canDropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectCanDropMimeData() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canDropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) CanDropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_CanDropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) CanDropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_CanDropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_CanFetchMore
|
|
func callbackQAbstractProxyModel_CanFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::canFetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canFetchMore"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).CanFetchMoreDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectCanFetchMore(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canFetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectCanFetchMore() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canFetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) CanFetchMore(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_CanFetchMore(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) CanFetchMoreDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_CanFetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_Data
|
|
func callbackQAbstractProxyModel_Data(ptr unsafe.Pointer, ptrName *C.char, proxyIndex unsafe.Pointer, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractProxyModel::data")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "data"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(*QModelIndex, int) *QVariant)(NewQModelIndexFromPointer(proxyIndex), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQAbstractProxyModelFromPointer(ptr).DataDefault(NewQModelIndexFromPointer(proxyIndex), int(role)))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectData(f func(proxyIndex *QModelIndex, role int) *QVariant) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "data", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectData() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "data")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) Data(proxyIndex QModelIndex_ITF, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractProxyModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractProxyModel_Data(ptr.Pointer(), PointerFromQModelIndex(proxyIndex), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DataDefault(proxyIndex QModelIndex_ITF, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractProxyModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractProxyModel_DataDefault(ptr.Pointer(), PointerFromQModelIndex(proxyIndex), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_DropMimeData
|
|
func callbackQAbstractProxyModel_DropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::dropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "dropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).DropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "dropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectDropMimeData() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "dropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_DropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_FetchMore
|
|
func callbackQAbstractProxyModel_FetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractProxyModel::fetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
|
|
signal.(func(*QModelIndex))(NewQModelIndexFromPointer(parent))
|
|
} else {
|
|
NewQAbstractProxyModelFromPointer(ptr).FetchMoreDefault(NewQModelIndexFromPointer(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectFetchMore(f func(parent *QModelIndex)) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectFetchMore() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) FetchMore(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_FetchMore(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) FetchMoreDefault(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_FetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_Flags
|
|
func callbackQAbstractProxyModel_Flags(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::flags")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "flags"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) Qt__ItemFlag)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return C.int(NewQAbstractProxyModelFromPointer(ptr).FlagsDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectFlags(f func(index *QModelIndex) Qt__ItemFlag) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "flags", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectFlags() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "flags")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QAbstractProxyModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QAbstractProxyModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) FlagsDefault(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QAbstractProxyModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QAbstractProxyModel_FlagsDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_HasChildren
|
|
func callbackQAbstractProxyModel_HasChildren(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::hasChildren")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "hasChildren"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).HasChildrenDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectHasChildren(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "hasChildren", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectHasChildren() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "hasChildren")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) HasChildren(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_HasChildren(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) HasChildrenDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_HasChildrenDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_HeaderData
|
|
func callbackQAbstractProxyModel_HeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractProxyModel::headerData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "headerData"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(int, Qt__Orientation, int) *QVariant)(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQAbstractProxyModelFromPointer(ptr).HeaderDataDefault(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectHeaderData(f func(section int, orientation Qt__Orientation, role int) *QVariant) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "headerData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectHeaderData() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "headerData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) HeaderData(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractProxyModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractProxyModel_HeaderData(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) HeaderDataDefault(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractProxyModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractProxyModel_HeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_MapFromSource
|
|
func callbackQAbstractProxyModel_MapFromSource(ptr unsafe.Pointer, ptrName *C.char, sourceIndex unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractProxyModel::mapFromSource")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapFromSource"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(sourceIndex)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(nil)
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectMapFromSource(f func(sourceIndex *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::mapFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapFromSource", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectMapFromSource(sourceIndex QModelIndex_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::mapFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapFromSource")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MapFromSource(sourceIndex QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractProxyModel::mapFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractProxyModel_MapFromSource(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_MapSelectionFromSource
|
|
func callbackQAbstractProxyModel_MapSelectionFromSource(ptr unsafe.Pointer, ptrName *C.char, sourceSelection unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractProxyModel::mapSelectionFromSource")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapSelectionFromSource"); signal != nil {
|
|
return PointerFromQItemSelection(signal.(func(*QItemSelection) *QItemSelection)(NewQItemSelectionFromPointer(sourceSelection)))
|
|
}
|
|
|
|
return PointerFromQItemSelection(NewQAbstractProxyModelFromPointer(ptr).MapSelectionFromSourceDefault(NewQItemSelectionFromPointer(sourceSelection)))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectMapSelectionFromSource(f func(sourceSelection *QItemSelection) *QItemSelection) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::mapSelectionFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapSelectionFromSource", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectMapSelectionFromSource() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::mapSelectionFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapSelectionFromSource")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MapSelectionFromSource(sourceSelection QItemSelection_ITF) *QItemSelection {
|
|
defer qt.Recovering("QAbstractProxyModel::mapSelectionFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QAbstractProxyModel_MapSelectionFromSource(ptr.Pointer(), PointerFromQItemSelection(sourceSelection)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MapSelectionFromSourceDefault(sourceSelection QItemSelection_ITF) *QItemSelection {
|
|
defer qt.Recovering("QAbstractProxyModel::mapSelectionFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QAbstractProxyModel_MapSelectionFromSourceDefault(ptr.Pointer(), PointerFromQItemSelection(sourceSelection)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_MapSelectionToSource
|
|
func callbackQAbstractProxyModel_MapSelectionToSource(ptr unsafe.Pointer, ptrName *C.char, proxySelection unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractProxyModel::mapSelectionToSource")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapSelectionToSource"); signal != nil {
|
|
return PointerFromQItemSelection(signal.(func(*QItemSelection) *QItemSelection)(NewQItemSelectionFromPointer(proxySelection)))
|
|
}
|
|
|
|
return PointerFromQItemSelection(NewQAbstractProxyModelFromPointer(ptr).MapSelectionToSourceDefault(NewQItemSelectionFromPointer(proxySelection)))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectMapSelectionToSource(f func(proxySelection *QItemSelection) *QItemSelection) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::mapSelectionToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapSelectionToSource", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectMapSelectionToSource() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::mapSelectionToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapSelectionToSource")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MapSelectionToSource(proxySelection QItemSelection_ITF) *QItemSelection {
|
|
defer qt.Recovering("QAbstractProxyModel::mapSelectionToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QAbstractProxyModel_MapSelectionToSource(ptr.Pointer(), PointerFromQItemSelection(proxySelection)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MapSelectionToSourceDefault(proxySelection QItemSelection_ITF) *QItemSelection {
|
|
defer qt.Recovering("QAbstractProxyModel::mapSelectionToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QAbstractProxyModel_MapSelectionToSourceDefault(ptr.Pointer(), PointerFromQItemSelection(proxySelection)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_MapToSource
|
|
func callbackQAbstractProxyModel_MapToSource(ptr unsafe.Pointer, ptrName *C.char, proxyIndex unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractProxyModel::mapToSource")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapToSource"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(proxyIndex)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(nil)
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectMapToSource(f func(proxyIndex *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::mapToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapToSource", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectMapToSource(proxyIndex QModelIndex_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::mapToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapToSource")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MapToSource(proxyIndex QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractProxyModel::mapToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractProxyModel_MapToSource(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_MimeTypes
|
|
func callbackQAbstractProxyModel_MimeTypes(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QAbstractProxyModel::mimeTypes")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mimeTypes"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(NewQAbstractProxyModelFromPointer(ptr).MimeTypesDefault(), "|"))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectMimeTypes(f func() []string) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mimeTypes", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectMimeTypes() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mimeTypes")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MimeTypes() []string {
|
|
defer qt.Recovering("QAbstractProxyModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QAbstractProxyModel_MimeTypes(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MimeTypesDefault() []string {
|
|
defer qt.Recovering("QAbstractProxyModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QAbstractProxyModel_MimeTypesDefault(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_ResetInternalData
|
|
func callbackQAbstractProxyModel_ResetInternalData(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractProxyModel::resetInternalData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resetInternalData"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectResetInternalData(f func()) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resetInternalData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectResetInternalData() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resetInternalData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ResetInternalData() {
|
|
defer qt.Recovering("QAbstractProxyModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_ResetInternalData(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_Revert
|
|
func callbackQAbstractProxyModel_Revert(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractProxyModel::revert")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractProxyModelFromPointer(ptr).RevertDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectRevert(f func()) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "revert", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectRevert() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "revert")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) Revert() {
|
|
defer qt.Recovering("QAbstractProxyModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_Revert(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) RevertDefault() {
|
|
defer qt.Recovering("QAbstractProxyModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_RevertDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_SetData
|
|
func callbackQAbstractProxyModel_SetData(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::setData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, *QVariant, int) bool)(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).SetDataDefault(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectSetData(f func(index *QModelIndex, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectSetData() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SetData(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_SetData(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SetDataDefault(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_SetDataDefault(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_SetHeaderData
|
|
func callbackQAbstractProxyModel_SetHeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::setHeaderData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setHeaderData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, Qt__Orientation, *QVariant, int) bool)(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).SetHeaderDataDefault(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectSetHeaderData(f func(section int, orientation Qt__Orientation, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setHeaderData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectSetHeaderData() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setHeaderData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SetHeaderData(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_SetHeaderData(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SetHeaderDataDefault(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_SetHeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_SetSourceModel
|
|
func callbackQAbstractProxyModel_SetSourceModel(ptr unsafe.Pointer, ptrName *C.char, sourceModel unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractProxyModel::setSourceModel")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setSourceModel"); signal != nil {
|
|
signal.(func(*QAbstractItemModel))(NewQAbstractItemModelFromPointer(sourceModel))
|
|
} else {
|
|
NewQAbstractProxyModelFromPointer(ptr).SetSourceModelDefault(NewQAbstractItemModelFromPointer(sourceModel))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectSetSourceModel(f func(sourceModel *QAbstractItemModel)) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::setSourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setSourceModel", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectSetSourceModel() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::setSourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setSourceModel")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SetSourceModel(sourceModel QAbstractItemModel_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::setSourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_SetSourceModel(ptr.Pointer(), PointerFromQAbstractItemModel(sourceModel))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SetSourceModelDefault(sourceModel QAbstractItemModel_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::setSourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_SetSourceModelDefault(ptr.Pointer(), PointerFromQAbstractItemModel(sourceModel))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_Sibling
|
|
func callbackQAbstractProxyModel_Sibling(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, idx unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractProxyModel::sibling")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sibling"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(idx)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQAbstractProxyModelFromPointer(ptr).SiblingDefault(int(row), int(column), NewQModelIndexFromPointer(idx)))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectSibling(f func(row int, column int, idx *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sibling", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectSibling() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sibling")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) Sibling(row int, column int, idx QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractProxyModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractProxyModel_Sibling(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SiblingDefault(row int, column int, idx QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractProxyModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractProxyModel_SiblingDefault(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_Sort
|
|
func callbackQAbstractProxyModel_Sort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
|
|
defer qt.Recovering("callback QAbstractProxyModel::sort")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
|
|
signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
|
|
} else {
|
|
NewQAbstractProxyModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sort", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectSort() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sort")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) Sort(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QAbstractProxyModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SortDefault(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QAbstractProxyModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SourceModel() *QAbstractItemModel {
|
|
defer qt.Recovering("QAbstractProxyModel::sourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractItemModelFromPointer(C.QAbstractProxyModel_SourceModel(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_SourceModelChanged
|
|
func callbackQAbstractProxyModel_SourceModelChanged(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractProxyModel::sourceModelChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sourceModelChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectSourceModelChanged(f func()) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::sourceModelChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_ConnectSourceModelChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "sourceModelChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectSourceModelChanged() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::sourceModelChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_DisconnectSourceModelChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sourceModelChanged")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_Span
|
|
func callbackQAbstractProxyModel_Span(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractProxyModel::span")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "span"); signal != nil {
|
|
return PointerFromQSize(signal.(func(*QModelIndex) *QSize)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQSize(NewQAbstractProxyModelFromPointer(ptr).SpanDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectSpan(f func(index *QModelIndex) *QSize) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "span", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectSpan() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "span")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) Span(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QAbstractProxyModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QAbstractProxyModel_Span(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SpanDefault(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QAbstractProxyModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QAbstractProxyModel_SpanDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_Submit
|
|
func callbackQAbstractProxyModel_Submit(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::submit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "submit"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).SubmitDefault()))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectSubmit(f func() bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "submit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectSubmit() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "submit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) Submit() bool {
|
|
defer qt.Recovering("QAbstractProxyModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_Submit(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SubmitDefault() bool {
|
|
defer qt.Recovering("QAbstractProxyModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_SubmitDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_SupportedDragActions
|
|
func callbackQAbstractProxyModel_SupportedDragActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::supportedDragActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDragActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQAbstractProxyModelFromPointer(ptr).SupportedDragActionsDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectSupportedDragActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDragActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectSupportedDragActions() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDragActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SupportedDragActions() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractProxyModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractProxyModel_SupportedDragActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SupportedDragActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractProxyModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractProxyModel_SupportedDragActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_SupportedDropActions
|
|
func callbackQAbstractProxyModel_SupportedDropActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::supportedDropActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDropActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQAbstractProxyModelFromPointer(ptr).SupportedDropActionsDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectSupportedDropActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDropActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectSupportedDropActions() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDropActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SupportedDropActions() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractProxyModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractProxyModel_SupportedDropActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) SupportedDropActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractProxyModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractProxyModel_SupportedDropActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DestroyQAbstractProxyModel() {
|
|
defer qt.Recovering("QAbstractProxyModel::~QAbstractProxyModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractProxyModel_DestroyQAbstractProxyModel(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_ColumnCount
|
|
func callbackQAbstractProxyModel_ColumnCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::columnCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(0)
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectColumnCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectColumnCount() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ColumnCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QAbstractProxyModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractProxyModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_Index
|
|
func callbackQAbstractProxyModel_Index(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractProxyModel::index")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "index"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(nil)
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "index", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectIndex() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "index")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractProxyModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractProxyModel_Index(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_InsertColumns
|
|
func callbackQAbstractProxyModel_InsertColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::insertColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).InsertColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectInsertColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectInsertColumns() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) InsertColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_InsertColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) InsertColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_InsertColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_InsertRows
|
|
func callbackQAbstractProxyModel_InsertRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::insertRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).InsertRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectInsertRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectInsertRows() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) InsertRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_InsertRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) InsertRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_InsertRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_MoveColumns
|
|
func callbackQAbstractProxyModel_MoveColumns(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceColumn C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::moveColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).MoveColumnsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectMoveColumns(f func(sourceParent *QModelIndex, sourceColumn int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectMoveColumns() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MoveColumns(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_MoveColumns(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MoveColumnsDefault(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_MoveColumnsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_MoveRows
|
|
func callbackQAbstractProxyModel_MoveRows(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceRow C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::moveRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).MoveRowsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectMoveRows(f func(sourceParent *QModelIndex, sourceRow int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectMoveRows() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MoveRows(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_MoveRows(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MoveRowsDefault(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_MoveRowsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_Parent
|
|
func callbackQAbstractProxyModel_Parent(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractProxyModel::parent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "parent"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(nil)
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectParent(f func(index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "parent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectParent() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "parent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) Parent(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractProxyModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractProxyModel_Parent(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_RemoveColumns
|
|
func callbackQAbstractProxyModel_RemoveColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::removeColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).RemoveColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectRemoveColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectRemoveColumns() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) RemoveColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_RemoveColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) RemoveColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_RemoveColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_RemoveRows
|
|
func callbackQAbstractProxyModel_RemoveRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::removeRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).RemoveRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectRemoveRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectRemoveRows() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) RemoveRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_RemoveRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) RemoveRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_RemoveRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_RowCount
|
|
func callbackQAbstractProxyModel_RowCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::rowCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(0)
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectRowCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectRowCount() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) RowCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QAbstractProxyModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractProxyModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_TimerEvent
|
|
func callbackQAbstractProxyModel_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractProxyModel::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractProxyModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_ChildEvent
|
|
func callbackQAbstractProxyModel_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractProxyModel::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractProxyModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_ConnectNotify
|
|
func callbackQAbstractProxyModel_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractProxyModel::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractProxyModelFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_CustomEvent
|
|
func callbackQAbstractProxyModel_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractProxyModel::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractProxyModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_DeleteLater
|
|
func callbackQAbstractProxyModel_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractProxyModel::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractProxyModelFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DeleteLater() {
|
|
defer qt.Recovering("QAbstractProxyModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractProxyModel_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DeleteLaterDefault() {
|
|
defer qt.Recovering("QAbstractProxyModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractProxyModel_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_DisconnectNotify
|
|
func callbackQAbstractProxyModel_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractProxyModel::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractProxyModelFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractProxyModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractProxyModel_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_Event
|
|
func callbackQAbstractProxyModel_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_EventFilter
|
|
func callbackQAbstractProxyModel_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractProxyModel::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractProxyModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractProxyModel_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractProxyModel_MetaObject
|
|
func callbackQAbstractProxyModel_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractProxyModel::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQAbstractProxyModelFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QAbstractProxyModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QAbstractProxyModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QAbstractProxyModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractProxyModel_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractProxyModel) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QAbstractProxyModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractProxyModel_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAbstractState struct {
|
|
QObject
|
|
}
|
|
|
|
type QAbstractState_ITF interface {
|
|
QObject_ITF
|
|
QAbstractState_PTR() *QAbstractState
|
|
}
|
|
|
|
func (p *QAbstractState) QAbstractState_PTR() *QAbstractState {
|
|
return p
|
|
}
|
|
|
|
func (p *QAbstractState) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAbstractState) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractState(ptr QAbstractState_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractState_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractStateFromPointer(ptr unsafe.Pointer) *QAbstractState {
|
|
var n = new(QAbstractState)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAbstractStateFromPointer(ptr unsafe.Pointer) *QAbstractState {
|
|
var n = NewQAbstractStateFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QAbstractState_") {
|
|
n.SetObjectName("QAbstractState_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQAbstractState(parent QState_ITF) *QAbstractState {
|
|
defer qt.Recovering("QAbstractState::QAbstractState")
|
|
|
|
return newQAbstractStateFromPointer(C.QAbstractState_NewQAbstractState(PointerFromQState(parent)))
|
|
}
|
|
|
|
func (ptr *QAbstractState) Active() bool {
|
|
defer qt.Recovering("QAbstractState::active")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractState_Active(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractState_ActiveChanged
|
|
func callbackQAbstractState_ActiveChanged(ptr unsafe.Pointer, ptrName *C.char, active C.int) {
|
|
defer qt.Recovering("callback QAbstractState::activeChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "activeChanged"); signal != nil {
|
|
signal.(func(bool))(int(active) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectActiveChanged(f func(active bool)) {
|
|
defer qt.Recovering("connect QAbstractState::activeChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_ConnectActiveChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "activeChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectActiveChanged() {
|
|
defer qt.Recovering("disconnect QAbstractState::activeChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_DisconnectActiveChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "activeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) ActiveChanged(active bool) {
|
|
defer qt.Recovering("QAbstractState::activeChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_ActiveChanged(ptr.Pointer(), C.int(qt.GoBoolToInt(active)))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractState_Entered
|
|
func callbackQAbstractState_Entered(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractState::entered")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "entered"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectEntered(f func()) {
|
|
defer qt.Recovering("connect QAbstractState::entered")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_ConnectEntered(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "entered", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectEntered() {
|
|
defer qt.Recovering("disconnect QAbstractState::entered")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_DisconnectEntered(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "entered")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractState_Event
|
|
func callbackQAbstractState_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractState::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractStateFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QAbstractState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractState_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractState) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractState_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractState_Exited
|
|
func callbackQAbstractState_Exited(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractState::exited")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "exited"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectExited(f func()) {
|
|
defer qt.Recovering("connect QAbstractState::exited")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_ConnectExited(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "exited", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectExited() {
|
|
defer qt.Recovering("disconnect QAbstractState::exited")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_DisconnectExited(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "exited")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) Machine() *QStateMachine {
|
|
defer qt.Recovering("QAbstractState::machine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStateMachineFromPointer(C.QAbstractState_Machine(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractState_OnEntry
|
|
func callbackQAbstractState_OnEntry(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractState::onEntry")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onEntry"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectOnEntry(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QAbstractState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onEntry", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectOnEntry(event QEvent_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onEntry")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) OnEntry(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractState_OnExit
|
|
func callbackQAbstractState_OnExit(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractState::onExit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onExit"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectOnExit(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QAbstractState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onExit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectOnExit(event QEvent_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onExit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) OnExit(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_OnExit(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) ParentState() *QState {
|
|
defer qt.Recovering("QAbstractState::parentState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStateFromPointer(C.QAbstractState_ParentState(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractState) DestroyQAbstractState() {
|
|
defer qt.Recovering("QAbstractState::~QAbstractState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractState_DestroyQAbstractState(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractState_TimerEvent
|
|
func callbackQAbstractState_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractState::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractStateFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QAbstractState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QAbstractState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractState_ChildEvent
|
|
func callbackQAbstractState_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractState::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractStateFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QAbstractState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QAbstractState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractState_ConnectNotify
|
|
func callbackQAbstractState_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractState::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractStateFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractState_CustomEvent
|
|
func callbackQAbstractState_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractState::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractStateFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QAbstractState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QAbstractState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractState_DeleteLater
|
|
func callbackQAbstractState_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractState::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractStateFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QAbstractState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QAbstractState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DeleteLater() {
|
|
defer qt.Recovering("QAbstractState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractState_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DeleteLaterDefault() {
|
|
defer qt.Recovering("QAbstractState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractState_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractState_DisconnectNotify
|
|
func callbackQAbstractState_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractState::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractStateFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractState_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractState_EventFilter
|
|
func callbackQAbstractState_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractState::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractStateFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QAbstractState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractState_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractState) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractState_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractState_MetaObject
|
|
func callbackQAbstractState_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractState::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQAbstractStateFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractState) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QAbstractState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QAbstractState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractState) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QAbstractState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractState_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractState) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QAbstractState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractState_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAbstractTableModel struct {
|
|
QAbstractItemModel
|
|
}
|
|
|
|
type QAbstractTableModel_ITF interface {
|
|
QAbstractItemModel_ITF
|
|
QAbstractTableModel_PTR() *QAbstractTableModel
|
|
}
|
|
|
|
func (p *QAbstractTableModel) QAbstractTableModel_PTR() *QAbstractTableModel {
|
|
return p
|
|
}
|
|
|
|
func (p *QAbstractTableModel) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractItemModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAbstractTableModel) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractItemModel_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractTableModel(ptr QAbstractTableModel_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractTableModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractTableModelFromPointer(ptr unsafe.Pointer) *QAbstractTableModel {
|
|
var n = new(QAbstractTableModel)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAbstractTableModelFromPointer(ptr unsafe.Pointer) *QAbstractTableModel {
|
|
var n = NewQAbstractTableModelFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QAbstractTableModel_") {
|
|
n.SetObjectName("QAbstractTableModel_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_Index
|
|
func callbackQAbstractTableModel_Index(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractTableModel::index")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "index"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQAbstractTableModelFromPointer(ptr).IndexDefault(int(row), int(column), NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractTableModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "index", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectIndex() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "index")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractTableModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractTableModel_Index(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) IndexDefault(row int, column int, parent QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractTableModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractTableModel_IndexDefault(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractTableModel(parent QObject_ITF) *QAbstractTableModel {
|
|
defer qt.Recovering("QAbstractTableModel::QAbstractTableModel")
|
|
|
|
return newQAbstractTableModelFromPointer(C.QAbstractTableModel_NewQAbstractTableModel(PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_DropMimeData
|
|
func callbackQAbstractTableModel_DropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::dropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "dropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).DropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "dropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectDropMimeData() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "dropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_DropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_Flags
|
|
func callbackQAbstractTableModel_Flags(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::flags")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "flags"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) Qt__ItemFlag)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return C.int(NewQAbstractTableModelFromPointer(ptr).FlagsDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectFlags(f func(index *QModelIndex) Qt__ItemFlag) {
|
|
defer qt.Recovering("connect QAbstractTableModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "flags", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectFlags() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "flags")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QAbstractTableModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QAbstractTableModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) FlagsDefault(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QAbstractTableModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QAbstractTableModel_FlagsDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_Sibling
|
|
func callbackQAbstractTableModel_Sibling(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, idx unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractTableModel::sibling")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sibling"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(idx)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQAbstractTableModelFromPointer(ptr).SiblingDefault(int(row), int(column), NewQModelIndexFromPointer(idx)))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectSibling(f func(row int, column int, idx *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractTableModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sibling", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectSibling() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sibling")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) Sibling(row int, column int, idx QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractTableModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractTableModel_Sibling(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) SiblingDefault(row int, column int, idx QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractTableModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractTableModel_SiblingDefault(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DestroyQAbstractTableModel() {
|
|
defer qt.Recovering("QAbstractTableModel::~QAbstractTableModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractTableModel_DestroyQAbstractTableModel(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_Buddy
|
|
func callbackQAbstractTableModel_Buddy(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractTableModel::buddy")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "buddy"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQAbstractTableModelFromPointer(ptr).BuddyDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectBuddy(f func(index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractTableModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "buddy", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectBuddy() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "buddy")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) Buddy(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractTableModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractTableModel_Buddy(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) BuddyDefault(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractTableModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractTableModel_BuddyDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_CanDropMimeData
|
|
func callbackQAbstractTableModel_CanDropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::canDropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canDropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).CanDropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectCanDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canDropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectCanDropMimeData() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canDropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) CanDropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_CanDropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) CanDropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_CanDropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_CanFetchMore
|
|
func callbackQAbstractTableModel_CanFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::canFetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canFetchMore"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).CanFetchMoreDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectCanFetchMore(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canFetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectCanFetchMore() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canFetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) CanFetchMore(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_CanFetchMore(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) CanFetchMoreDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_CanFetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_ColumnCount
|
|
func callbackQAbstractTableModel_ColumnCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::columnCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(0)
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectColumnCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QAbstractTableModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectColumnCount() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ColumnCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QAbstractTableModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractTableModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_Data
|
|
func callbackQAbstractTableModel_Data(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractTableModel::data")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "data"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(*QModelIndex, int) *QVariant)(NewQModelIndexFromPointer(index), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(nil)
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectData(f func(index *QModelIndex, role int) *QVariant) {
|
|
defer qt.Recovering("connect QAbstractTableModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "data", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectData() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "data")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) Data(index QModelIndex_ITF, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractTableModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractTableModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_FetchMore
|
|
func callbackQAbstractTableModel_FetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractTableModel::fetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
|
|
signal.(func(*QModelIndex))(NewQModelIndexFromPointer(parent))
|
|
} else {
|
|
NewQAbstractTableModelFromPointer(ptr).FetchMoreDefault(NewQModelIndexFromPointer(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectFetchMore(f func(parent *QModelIndex)) {
|
|
defer qt.Recovering("connect QAbstractTableModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectFetchMore() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) FetchMore(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QAbstractTableModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_FetchMore(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) FetchMoreDefault(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QAbstractTableModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_FetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_HasChildren
|
|
func callbackQAbstractTableModel_HasChildren(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::hasChildren")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "hasChildren"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).HasChildrenDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectHasChildren(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "hasChildren", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectHasChildren() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "hasChildren")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) HasChildren(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_HasChildren(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) HasChildrenDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_HasChildrenDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_HeaderData
|
|
func callbackQAbstractTableModel_HeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractTableModel::headerData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "headerData"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(int, Qt__Orientation, int) *QVariant)(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQAbstractTableModelFromPointer(ptr).HeaderDataDefault(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectHeaderData(f func(section int, orientation Qt__Orientation, role int) *QVariant) {
|
|
defer qt.Recovering("connect QAbstractTableModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "headerData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectHeaderData() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "headerData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) HeaderData(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractTableModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractTableModel_HeaderData(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) HeaderDataDefault(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QAbstractTableModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAbstractTableModel_HeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_InsertColumns
|
|
func callbackQAbstractTableModel_InsertColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::insertColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).InsertColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectInsertColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectInsertColumns() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) InsertColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_InsertColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) InsertColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_InsertColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_InsertRows
|
|
func callbackQAbstractTableModel_InsertRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::insertRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).InsertRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectInsertRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectInsertRows() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) InsertRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_InsertRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) InsertRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_InsertRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_MimeTypes
|
|
func callbackQAbstractTableModel_MimeTypes(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QAbstractTableModel::mimeTypes")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mimeTypes"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(NewQAbstractTableModelFromPointer(ptr).MimeTypesDefault(), "|"))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectMimeTypes(f func() []string) {
|
|
defer qt.Recovering("connect QAbstractTableModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mimeTypes", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectMimeTypes() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mimeTypes")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) MimeTypes() []string {
|
|
defer qt.Recovering("QAbstractTableModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QAbstractTableModel_MimeTypes(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) MimeTypesDefault() []string {
|
|
defer qt.Recovering("QAbstractTableModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QAbstractTableModel_MimeTypesDefault(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_MoveColumns
|
|
func callbackQAbstractTableModel_MoveColumns(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceColumn C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::moveColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).MoveColumnsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectMoveColumns(f func(sourceParent *QModelIndex, sourceColumn int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectMoveColumns() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) MoveColumns(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractTableModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_MoveColumns(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) MoveColumnsDefault(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractTableModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_MoveColumnsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_MoveRows
|
|
func callbackQAbstractTableModel_MoveRows(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceRow C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::moveRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).MoveRowsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectMoveRows(f func(sourceParent *QModelIndex, sourceRow int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectMoveRows() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) MoveRows(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractTableModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_MoveRows(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) MoveRowsDefault(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QAbstractTableModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_MoveRowsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_Parent
|
|
func callbackQAbstractTableModel_Parent(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractTableModel::parent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "parent"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQAbstractTableModelFromPointer(ptr).ParentDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectParent(f func(index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QAbstractTableModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "parent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectParent() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "parent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) Parent(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractTableModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractTableModel_Parent(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ParentDefault(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QAbstractTableModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QAbstractTableModel_ParentDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_RemoveColumns
|
|
func callbackQAbstractTableModel_RemoveColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::removeColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).RemoveColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectRemoveColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectRemoveColumns() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) RemoveColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_RemoveColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) RemoveColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_RemoveColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_RemoveRows
|
|
func callbackQAbstractTableModel_RemoveRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::removeRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).RemoveRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectRemoveRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectRemoveRows() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) RemoveRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_RemoveRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) RemoveRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_RemoveRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_ResetInternalData
|
|
func callbackQAbstractTableModel_ResetInternalData(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractTableModel::resetInternalData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resetInternalData"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractTableModelFromPointer(ptr).ResetInternalDataDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectResetInternalData(f func()) {
|
|
defer qt.Recovering("connect QAbstractTableModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resetInternalData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectResetInternalData() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resetInternalData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ResetInternalData() {
|
|
defer qt.Recovering("QAbstractTableModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_ResetInternalData(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ResetInternalDataDefault() {
|
|
defer qt.Recovering("QAbstractTableModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_ResetInternalDataDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_Revert
|
|
func callbackQAbstractTableModel_Revert(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractTableModel::revert")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractTableModelFromPointer(ptr).RevertDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectRevert(f func()) {
|
|
defer qt.Recovering("connect QAbstractTableModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "revert", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectRevert() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "revert")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) Revert() {
|
|
defer qt.Recovering("QAbstractTableModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_Revert(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) RevertDefault() {
|
|
defer qt.Recovering("QAbstractTableModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_RevertDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_RowCount
|
|
func callbackQAbstractTableModel_RowCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::rowCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(0)
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectRowCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QAbstractTableModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectRowCount() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) RowCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QAbstractTableModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAbstractTableModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_SetData
|
|
func callbackQAbstractTableModel_SetData(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::setData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, *QVariant, int) bool)(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).SetDataDefault(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectSetData(f func(index *QModelIndex, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectSetData() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) SetData(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractTableModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_SetData(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) SetDataDefault(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractTableModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_SetDataDefault(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_SetHeaderData
|
|
func callbackQAbstractTableModel_SetHeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::setHeaderData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setHeaderData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, Qt__Orientation, *QVariant, int) bool)(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).SetHeaderDataDefault(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectSetHeaderData(f func(section int, orientation Qt__Orientation, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setHeaderData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectSetHeaderData() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setHeaderData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) SetHeaderData(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractTableModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_SetHeaderData(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) SetHeaderDataDefault(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QAbstractTableModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_SetHeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_Sort
|
|
func callbackQAbstractTableModel_Sort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
|
|
defer qt.Recovering("callback QAbstractTableModel::sort")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
|
|
signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
|
|
} else {
|
|
NewQAbstractTableModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
|
|
defer qt.Recovering("connect QAbstractTableModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sort", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectSort() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sort")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) Sort(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QAbstractTableModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) SortDefault(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QAbstractTableModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_Span
|
|
func callbackQAbstractTableModel_Span(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractTableModel::span")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "span"); signal != nil {
|
|
return PointerFromQSize(signal.(func(*QModelIndex) *QSize)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQSize(NewQAbstractTableModelFromPointer(ptr).SpanDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectSpan(f func(index *QModelIndex) *QSize) {
|
|
defer qt.Recovering("connect QAbstractTableModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "span", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectSpan() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "span")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) Span(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QAbstractTableModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QAbstractTableModel_Span(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) SpanDefault(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QAbstractTableModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QAbstractTableModel_SpanDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_Submit
|
|
func callbackQAbstractTableModel_Submit(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::submit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "submit"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).SubmitDefault()))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectSubmit(f func() bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "submit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectSubmit() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "submit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) Submit() bool {
|
|
defer qt.Recovering("QAbstractTableModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_Submit(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) SubmitDefault() bool {
|
|
defer qt.Recovering("QAbstractTableModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_SubmitDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_SupportedDragActions
|
|
func callbackQAbstractTableModel_SupportedDragActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::supportedDragActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDragActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQAbstractTableModelFromPointer(ptr).SupportedDragActionsDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectSupportedDragActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QAbstractTableModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDragActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectSupportedDragActions() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDragActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) SupportedDragActions() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractTableModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractTableModel_SupportedDragActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) SupportedDragActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractTableModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractTableModel_SupportedDragActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_SupportedDropActions
|
|
func callbackQAbstractTableModel_SupportedDropActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::supportedDropActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDropActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQAbstractTableModelFromPointer(ptr).SupportedDropActionsDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectSupportedDropActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QAbstractTableModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDropActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectSupportedDropActions() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDropActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) SupportedDropActions() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractTableModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractTableModel_SupportedDropActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) SupportedDropActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QAbstractTableModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QAbstractTableModel_SupportedDropActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_TimerEvent
|
|
func callbackQAbstractTableModel_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractTableModel::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractTableModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QAbstractTableModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTableModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTableModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_ChildEvent
|
|
func callbackQAbstractTableModel_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractTableModel::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractTableModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QAbstractTableModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTableModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTableModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_ConnectNotify
|
|
func callbackQAbstractTableModel_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractTableModel::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractTableModelFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractTableModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractTableModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractTableModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_CustomEvent
|
|
func callbackQAbstractTableModel_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractTableModel::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractTableModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QAbstractTableModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTableModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTableModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_DeleteLater
|
|
func callbackQAbstractTableModel_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractTableModel::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractTableModelFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QAbstractTableModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DeleteLater() {
|
|
defer qt.Recovering("QAbstractTableModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractTableModel_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DeleteLaterDefault() {
|
|
defer qt.Recovering("QAbstractTableModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractTableModel_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_DisconnectNotify
|
|
func callbackQAbstractTableModel_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractTableModel::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractTableModelFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractTableModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractTableModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractTableModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTableModel_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_Event
|
|
func callbackQAbstractTableModel_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_EventFilter
|
|
func callbackQAbstractTableModel_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTableModel::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTableModelFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractTableModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractTableModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTableModel_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTableModel_MetaObject
|
|
func callbackQAbstractTableModel_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractTableModel::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQAbstractTableModelFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QAbstractTableModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QAbstractTableModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QAbstractTableModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractTableModel_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractTableModel) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QAbstractTableModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractTableModel_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//QAbstractTransition::TransitionType
|
|
type QAbstractTransition__TransitionType int64
|
|
|
|
const (
|
|
QAbstractTransition__ExternalTransition = QAbstractTransition__TransitionType(0)
|
|
QAbstractTransition__InternalTransition = QAbstractTransition__TransitionType(1)
|
|
)
|
|
|
|
type QAbstractTransition struct {
|
|
QObject
|
|
}
|
|
|
|
type QAbstractTransition_ITF interface {
|
|
QObject_ITF
|
|
QAbstractTransition_PTR() *QAbstractTransition
|
|
}
|
|
|
|
func (p *QAbstractTransition) QAbstractTransition_PTR() *QAbstractTransition {
|
|
return p
|
|
}
|
|
|
|
func (p *QAbstractTransition) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAbstractTransition) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractTransition(ptr QAbstractTransition_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractTransition_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractTransitionFromPointer(ptr unsafe.Pointer) *QAbstractTransition {
|
|
var n = new(QAbstractTransition)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAbstractTransitionFromPointer(ptr unsafe.Pointer) *QAbstractTransition {
|
|
var n = NewQAbstractTransitionFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QAbstractTransition_") {
|
|
n.SetObjectName("QAbstractTransition_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQAbstractTransition(sourceState QState_ITF) *QAbstractTransition {
|
|
defer qt.Recovering("QAbstractTransition::QAbstractTransition")
|
|
|
|
return newQAbstractTransitionFromPointer(C.QAbstractTransition_NewQAbstractTransition(PointerFromQState(sourceState)))
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) AddAnimation(animation QAbstractAnimation_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::addAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_AddAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTransition_Event
|
|
func callbackQAbstractTransition_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTransition::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTransitionFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractTransition::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QAbstractTransition::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractTransition::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTransition_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractTransition::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTransition_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTransition_EventTest
|
|
func callbackQAbstractTransition_EventTest(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTransition::eventTest")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventTest"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(false))
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectEventTest(f func(event *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractTransition::eventTest")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventTest", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectEventTest(event QEvent_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractTransition::eventTest")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventTest")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) EventTest(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractTransition::eventTest")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTransition_EventTest(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) Machine() *QStateMachine {
|
|
defer qt.Recovering("QAbstractTransition::machine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStateMachineFromPointer(C.QAbstractTransition_Machine(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractTransition_OnTransition
|
|
func callbackQAbstractTransition_OnTransition(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractTransition::onTransition")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onTransition"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectOnTransition(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QAbstractTransition::onTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onTransition", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectOnTransition(event QEvent_ITF) {
|
|
defer qt.Recovering("disconnect QAbstractTransition::onTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onTransition")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) OnTransition(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::onTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_OnTransition(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) RemoveAnimation(animation QAbstractAnimation_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::removeAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_RemoveAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) SetTargetState(target QAbstractState_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::setTargetState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_SetTargetState(ptr.Pointer(), PointerFromQAbstractState(target))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) SetTransitionType(ty QAbstractTransition__TransitionType) {
|
|
defer qt.Recovering("QAbstractTransition::setTransitionType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_SetTransitionType(ptr.Pointer(), C.int(ty))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) SourceState() *QState {
|
|
defer qt.Recovering("QAbstractTransition::sourceState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStateFromPointer(C.QAbstractTransition_SourceState(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) TargetState() *QAbstractState {
|
|
defer qt.Recovering("QAbstractTransition::targetState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractStateFromPointer(C.QAbstractTransition_TargetState(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractTransition_TargetStateChanged
|
|
func callbackQAbstractTransition_TargetStateChanged(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractTransition::targetStateChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "targetStateChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectTargetStateChanged(f func()) {
|
|
defer qt.Recovering("connect QAbstractTransition::targetStateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_ConnectTargetStateChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "targetStateChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectTargetStateChanged() {
|
|
defer qt.Recovering("disconnect QAbstractTransition::targetStateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_DisconnectTargetStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "targetStateChanged")
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTransition_TargetStatesChanged
|
|
func callbackQAbstractTransition_TargetStatesChanged(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractTransition::targetStatesChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "targetStatesChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectTargetStatesChanged(f func()) {
|
|
defer qt.Recovering("connect QAbstractTransition::targetStatesChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_ConnectTargetStatesChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "targetStatesChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectTargetStatesChanged() {
|
|
defer qt.Recovering("disconnect QAbstractTransition::targetStatesChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_DisconnectTargetStatesChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "targetStatesChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) TransitionType() QAbstractTransition__TransitionType {
|
|
defer qt.Recovering("QAbstractTransition::transitionType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractTransition__TransitionType(C.QAbstractTransition_TransitionType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractTransition_Triggered
|
|
func callbackQAbstractTransition_Triggered(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractTransition::triggered")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "triggered"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectTriggered(f func()) {
|
|
defer qt.Recovering("connect QAbstractTransition::triggered")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_ConnectTriggered(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "triggered", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectTriggered() {
|
|
defer qt.Recovering("disconnect QAbstractTransition::triggered")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_DisconnectTriggered(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "triggered")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DestroyQAbstractTransition() {
|
|
defer qt.Recovering("QAbstractTransition::~QAbstractTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractTransition_DestroyQAbstractTransition(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTransition_TimerEvent
|
|
func callbackQAbstractTransition_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractTransition::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractTransitionFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QAbstractTransition::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QAbstractTransition::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTransition_ChildEvent
|
|
func callbackQAbstractTransition_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractTransition::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractTransitionFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QAbstractTransition::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QAbstractTransition::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTransition_ConnectNotify
|
|
func callbackQAbstractTransition_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractTransition::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractTransitionFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractTransition::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractTransition::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTransition_CustomEvent
|
|
func callbackQAbstractTransition_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractTransition::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractTransitionFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QAbstractTransition::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QAbstractTransition::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTransition_DeleteLater
|
|
func callbackQAbstractTransition_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAbstractTransition::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractTransitionFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QAbstractTransition::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QAbstractTransition::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DeleteLater() {
|
|
defer qt.Recovering("QAbstractTransition::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractTransition_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DeleteLaterDefault() {
|
|
defer qt.Recovering("QAbstractTransition::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAbstractTransition_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTransition_DisconnectNotify
|
|
func callbackQAbstractTransition_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAbstractTransition::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractTransitionFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAbstractTransition::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QAbstractTransition::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAbstractTransition::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractTransition_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractTransition_EventFilter
|
|
func callbackQAbstractTransition_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAbstractTransition::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAbstractTransitionFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QAbstractTransition::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QAbstractTransition::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractTransition::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTransition_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAbstractTransition::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractTransition_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractTransition_MetaObject
|
|
func callbackQAbstractTransition_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAbstractTransition::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQAbstractTransitionFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QAbstractTransition::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QAbstractTransition::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QAbstractTransition::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractTransition_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractTransition) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QAbstractTransition::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAbstractTransition_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAnimationGroup struct {
|
|
QAbstractAnimation
|
|
}
|
|
|
|
type QAnimationGroup_ITF interface {
|
|
QAbstractAnimation_ITF
|
|
QAnimationGroup_PTR() *QAnimationGroup
|
|
}
|
|
|
|
func (p *QAnimationGroup) QAnimationGroup_PTR() *QAnimationGroup {
|
|
return p
|
|
}
|
|
|
|
func (p *QAnimationGroup) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractAnimation_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAnimationGroup) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractAnimation_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAnimationGroup(ptr QAnimationGroup_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAnimationGroup_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAnimationGroupFromPointer(ptr unsafe.Pointer) *QAnimationGroup {
|
|
var n = new(QAnimationGroup)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAnimationGroupFromPointer(ptr unsafe.Pointer) *QAnimationGroup {
|
|
var n = NewQAnimationGroupFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QAnimationGroup_") {
|
|
n.SetObjectName("QAnimationGroup_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQAnimationGroup(parent QObject_ITF) *QAnimationGroup {
|
|
defer qt.Recovering("QAnimationGroup::QAnimationGroup")
|
|
|
|
return newQAnimationGroupFromPointer(C.QAnimationGroup_NewQAnimationGroup(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) AddAnimation(animation QAbstractAnimation_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::addAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_AddAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) AnimationAt(index int) *QAbstractAnimation {
|
|
defer qt.Recovering("QAnimationGroup::animationAt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractAnimationFromPointer(C.QAnimationGroup_AnimationAt(ptr.Pointer(), C.int(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) AnimationCount() int {
|
|
defer qt.Recovering("QAnimationGroup::animationCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAnimationGroup_AnimationCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) Clear() {
|
|
defer qt.Recovering("QAnimationGroup::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_Event
|
|
func callbackQAnimationGroup_Event(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAnimationGroup::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAnimationGroupFromPointer(ptr).EventDefault(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectEvent(f func(event *QEvent) bool) {
|
|
defer qt.Recovering("connect QAnimationGroup::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) Event(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAnimationGroup::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAnimationGroup_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) EventDefault(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAnimationGroup::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAnimationGroup_EventDefault(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) IndexOfAnimation(animation QAbstractAnimation_ITF) int {
|
|
defer qt.Recovering("QAnimationGroup::indexOfAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAnimationGroup_IndexOfAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) InsertAnimation(index int, animation QAbstractAnimation_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::insertAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_InsertAnimation(ptr.Pointer(), C.int(index), PointerFromQAbstractAnimation(animation))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) RemoveAnimation(animation QAbstractAnimation_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::removeAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_RemoveAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) TakeAnimation(index int) *QAbstractAnimation {
|
|
defer qt.Recovering("QAnimationGroup::takeAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractAnimationFromPointer(C.QAnimationGroup_TakeAnimation(ptr.Pointer(), C.int(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DestroyQAnimationGroup() {
|
|
defer qt.Recovering("QAnimationGroup::~QAnimationGroup")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAnimationGroup_DestroyQAnimationGroup(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_SetCurrentTime
|
|
func callbackQAnimationGroup_SetCurrentTime(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) {
|
|
defer qt.Recovering("callback QAnimationGroup::setCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(msecs))
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).SetCurrentTimeDefault(int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectSetCurrentTime(f func(msecs int)) {
|
|
defer qt.Recovering("connect QAnimationGroup::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectSetCurrentTime() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) SetCurrentTime(msecs int) {
|
|
defer qt.Recovering("QAnimationGroup::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_SetCurrentTime(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) SetCurrentTimeDefault(msecs int) {
|
|
defer qt.Recovering("QAnimationGroup::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_SetCurrentTimeDefault(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_Duration
|
|
func callbackQAnimationGroup_Duration(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QAnimationGroup::duration")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "duration"); signal != nil {
|
|
return C.int(signal.(func() int)())
|
|
}
|
|
|
|
return C.int(0)
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectDuration(f func() int) {
|
|
defer qt.Recovering("connect QAnimationGroup::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "duration", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectDuration() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) Duration() int {
|
|
defer qt.Recovering("QAnimationGroup::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAnimationGroup_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAnimationGroup_Pause
|
|
func callbackQAnimationGroup_Pause(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAnimationGroup::pause")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pause"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).PauseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectPause(f func()) {
|
|
defer qt.Recovering("connect QAnimationGroup::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pause", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectPause() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pause")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) Pause() {
|
|
defer qt.Recovering("QAnimationGroup::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_Pause(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) PauseDefault() {
|
|
defer qt.Recovering("QAnimationGroup::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_PauseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_Resume
|
|
func callbackQAnimationGroup_Resume(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAnimationGroup::resume")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resume"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).ResumeDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectResume(f func()) {
|
|
defer qt.Recovering("connect QAnimationGroup::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resume", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectResume() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) Resume() {
|
|
defer qt.Recovering("QAnimationGroup::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_Resume(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ResumeDefault() {
|
|
defer qt.Recovering("QAnimationGroup::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_ResumeDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_SetPaused
|
|
func callbackQAnimationGroup_SetPaused(ptr unsafe.Pointer, ptrName *C.char, paused C.int) {
|
|
defer qt.Recovering("callback QAnimationGroup::setPaused")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setPaused"); signal != nil {
|
|
signal.(func(bool))(int(paused) != 0)
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).SetPausedDefault(int(paused) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectSetPaused(f func(paused bool)) {
|
|
defer qt.Recovering("connect QAnimationGroup::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setPaused", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectSetPaused() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setPaused")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) SetPaused(paused bool) {
|
|
defer qt.Recovering("QAnimationGroup::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_SetPaused(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) SetPausedDefault(paused bool) {
|
|
defer qt.Recovering("QAnimationGroup::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_SetPausedDefault(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_Start
|
|
func callbackQAnimationGroup_Start(ptr unsafe.Pointer, ptrName *C.char, policy C.int) {
|
|
defer qt.Recovering("callback QAnimationGroup::start")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "start"); signal != nil {
|
|
signal.(func(QAbstractAnimation__DeletionPolicy))(QAbstractAnimation__DeletionPolicy(policy))
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).StartDefault(QAbstractAnimation__DeletionPolicy(policy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectStart(f func(policy QAbstractAnimation__DeletionPolicy)) {
|
|
defer qt.Recovering("connect QAnimationGroup::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "start", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectStart() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) Start(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QAnimationGroup::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_Start(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) StartDefault(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QAnimationGroup::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_StartDefault(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_Stop
|
|
func callbackQAnimationGroup_Stop(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAnimationGroup::stop")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectStop(f func()) {
|
|
defer qt.Recovering("connect QAnimationGroup::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "stop", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectStop() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) Stop() {
|
|
defer qt.Recovering("QAnimationGroup::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) StopDefault() {
|
|
defer qt.Recovering("QAnimationGroup::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_UpdateCurrentTime
|
|
func callbackQAnimationGroup_UpdateCurrentTime(ptr unsafe.Pointer, ptrName *C.char, currentTime C.int) {
|
|
defer qt.Recovering("callback QAnimationGroup::updateCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(currentTime))
|
|
} else {
|
|
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectUpdateCurrentTime(f func(currentTime int)) {
|
|
defer qt.Recovering("connect QAnimationGroup::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectUpdateCurrentTime() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) UpdateCurrentTime(currentTime int) {
|
|
defer qt.Recovering("QAnimationGroup::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_UpdateCurrentTime(ptr.Pointer(), C.int(currentTime))
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_UpdateDirection
|
|
func callbackQAnimationGroup_UpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
|
|
defer qt.Recovering("callback QAnimationGroup::updateDirection")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
|
|
signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
|
|
defer qt.Recovering("connect QAnimationGroup::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectUpdateDirection() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateDirection")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) UpdateDirection(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QAnimationGroup::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_UpdateDirection(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QAnimationGroup::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_UpdateState
|
|
func callbackQAnimationGroup_UpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
|
|
defer qt.Recovering("callback QAnimationGroup::updateState")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
|
|
signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
|
|
defer qt.Recovering("connect QAnimationGroup::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectUpdateState() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateState")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QAnimationGroup::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QAnimationGroup::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_TimerEvent
|
|
func callbackQAnimationGroup_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAnimationGroup::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QAnimationGroup::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_ChildEvent
|
|
func callbackQAnimationGroup_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAnimationGroup::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QAnimationGroup::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_ConnectNotify
|
|
func callbackQAnimationGroup_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAnimationGroup::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAnimationGroup::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_CustomEvent
|
|
func callbackQAnimationGroup_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAnimationGroup::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QAnimationGroup::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_DeleteLater
|
|
func callbackQAnimationGroup_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QAnimationGroup::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QAnimationGroup::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DeleteLater() {
|
|
defer qt.Recovering("QAnimationGroup::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAnimationGroup_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DeleteLaterDefault() {
|
|
defer qt.Recovering("QAnimationGroup::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QAnimationGroup_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_DisconnectNotify
|
|
func callbackQAnimationGroup_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QAnimationGroup::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAnimationGroupFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QAnimationGroup::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QAnimationGroup::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QAnimationGroup_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAnimationGroup_EventFilter
|
|
func callbackQAnimationGroup_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QAnimationGroup::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQAnimationGroupFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QAnimationGroup::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAnimationGroup::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAnimationGroup_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QAnimationGroup::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QAnimationGroup_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAnimationGroup_MetaObject
|
|
func callbackQAnimationGroup_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QAnimationGroup::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQAnimationGroupFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QAnimationGroup::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QAnimationGroup::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QAnimationGroup::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAnimationGroup_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAnimationGroup) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QAnimationGroup::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QAnimationGroup_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAssociativeIterable struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAssociativeIterable_ITF interface {
|
|
QAssociativeIterable_PTR() *QAssociativeIterable
|
|
}
|
|
|
|
func (p *QAssociativeIterable) QAssociativeIterable_PTR() *QAssociativeIterable {
|
|
return p
|
|
}
|
|
|
|
func (p *QAssociativeIterable) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAssociativeIterable) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQAssociativeIterable(ptr QAssociativeIterable_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAssociativeIterable_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAssociativeIterableFromPointer(ptr unsafe.Pointer) *QAssociativeIterable {
|
|
var n = new(QAssociativeIterable)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAssociativeIterableFromPointer(ptr unsafe.Pointer) *QAssociativeIterable {
|
|
var n = NewQAssociativeIterableFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QAssociativeIterable) Size() int {
|
|
defer qt.Recovering("QAssociativeIterable::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QAssociativeIterable_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAssociativeIterable) Value(key QVariant_ITF) *QVariant {
|
|
defer qt.Recovering("QAssociativeIterable::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QAssociativeIterable_Value(ptr.Pointer(), PointerFromQVariant(key)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAtomicInt struct {
|
|
QAtomicInteger
|
|
}
|
|
|
|
type QAtomicInt_ITF interface {
|
|
QAtomicInteger_ITF
|
|
QAtomicInt_PTR() *QAtomicInt
|
|
}
|
|
|
|
func (p *QAtomicInt) QAtomicInt_PTR() *QAtomicInt {
|
|
return p
|
|
}
|
|
|
|
func (p *QAtomicInt) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAtomicInteger_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAtomicInt) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAtomicInteger_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAtomicInt(ptr QAtomicInt_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAtomicInt_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAtomicIntFromPointer(ptr unsafe.Pointer) *QAtomicInt {
|
|
var n = new(QAtomicInt)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAtomicIntFromPointer(ptr unsafe.Pointer) *QAtomicInt {
|
|
var n = NewQAtomicIntFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QAtomicInteger struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAtomicInteger_ITF interface {
|
|
QAtomicInteger_PTR() *QAtomicInteger
|
|
}
|
|
|
|
func (p *QAtomicInteger) QAtomicInteger_PTR() *QAtomicInteger {
|
|
return p
|
|
}
|
|
|
|
func (p *QAtomicInteger) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAtomicInteger) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQAtomicInteger(ptr QAtomicInteger_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAtomicInteger_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAtomicIntegerFromPointer(ptr unsafe.Pointer) *QAtomicInteger {
|
|
var n = new(QAtomicInteger)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAtomicIntegerFromPointer(ptr unsafe.Pointer) *QAtomicInteger {
|
|
var n = NewQAtomicIntegerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QAtomicPointer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAtomicPointer_ITF interface {
|
|
QAtomicPointer_PTR() *QAtomicPointer
|
|
}
|
|
|
|
func (p *QAtomicPointer) QAtomicPointer_PTR() *QAtomicPointer {
|
|
return p
|
|
}
|
|
|
|
func (p *QAtomicPointer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QAtomicPointer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQAtomicPointer(ptr QAtomicPointer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAtomicPointer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAtomicPointerFromPointer(ptr unsafe.Pointer) *QAtomicPointer {
|
|
var n = new(QAtomicPointer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQAtomicPointerFromPointer(ptr unsafe.Pointer) *QAtomicPointer {
|
|
var n = NewQAtomicPointerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QBasicTimer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QBasicTimer_ITF interface {
|
|
QBasicTimer_PTR() *QBasicTimer
|
|
}
|
|
|
|
func (p *QBasicTimer) QBasicTimer_PTR() *QBasicTimer {
|
|
return p
|
|
}
|
|
|
|
func (p *QBasicTimer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QBasicTimer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQBasicTimer(ptr QBasicTimer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QBasicTimer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQBasicTimerFromPointer(ptr unsafe.Pointer) *QBasicTimer {
|
|
var n = new(QBasicTimer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQBasicTimerFromPointer(ptr unsafe.Pointer) *QBasicTimer {
|
|
var n = NewQBasicTimerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QBasicTimer) Start(msec int, object QObject_ITF) {
|
|
defer qt.Recovering("QBasicTimer::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBasicTimer_Start(ptr.Pointer(), C.int(msec), PointerFromQObject(object))
|
|
}
|
|
}
|
|
|
|
func NewQBasicTimer() *QBasicTimer {
|
|
defer qt.Recovering("QBasicTimer::QBasicTimer")
|
|
|
|
return newQBasicTimerFromPointer(C.QBasicTimer_NewQBasicTimer())
|
|
}
|
|
|
|
func (ptr *QBasicTimer) IsActive() bool {
|
|
defer qt.Recovering("QBasicTimer::isActive")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBasicTimer_IsActive(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBasicTimer) Start2(msec int, timerType Qt__TimerType, obj QObject_ITF) {
|
|
defer qt.Recovering("QBasicTimer::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBasicTimer_Start2(ptr.Pointer(), C.int(msec), C.int(timerType), PointerFromQObject(obj))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBasicTimer) Stop() {
|
|
defer qt.Recovering("QBasicTimer::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBasicTimer_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QBasicTimer) TimerId() int {
|
|
defer qt.Recovering("QBasicTimer::timerId")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QBasicTimer_TimerId(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QBasicTimer) DestroyQBasicTimer() {
|
|
defer qt.Recovering("QBasicTimer::~QBasicTimer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBasicTimer_DestroyQBasicTimer(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QBitArray struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QBitArray_ITF interface {
|
|
QBitArray_PTR() *QBitArray
|
|
}
|
|
|
|
func (p *QBitArray) QBitArray_PTR() *QBitArray {
|
|
return p
|
|
}
|
|
|
|
func (p *QBitArray) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QBitArray) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQBitArray(ptr QBitArray_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QBitArray_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQBitArrayFromPointer(ptr unsafe.Pointer) *QBitArray {
|
|
var n = new(QBitArray)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQBitArrayFromPointer(ptr unsafe.Pointer) *QBitArray {
|
|
var n = NewQBitArrayFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQBitArray() *QBitArray {
|
|
defer qt.Recovering("QBitArray::QBitArray")
|
|
|
|
return newQBitArrayFromPointer(C.QBitArray_NewQBitArray())
|
|
}
|
|
|
|
func NewQBitArray4(other QBitArray_ITF) *QBitArray {
|
|
defer qt.Recovering("QBitArray::QBitArray")
|
|
|
|
return newQBitArrayFromPointer(C.QBitArray_NewQBitArray4(PointerFromQBitArray(other)))
|
|
}
|
|
|
|
func NewQBitArray3(other QBitArray_ITF) *QBitArray {
|
|
defer qt.Recovering("QBitArray::QBitArray")
|
|
|
|
return newQBitArrayFromPointer(C.QBitArray_NewQBitArray3(PointerFromQBitArray(other)))
|
|
}
|
|
|
|
func NewQBitArray2(size int, value bool) *QBitArray {
|
|
defer qt.Recovering("QBitArray::QBitArray")
|
|
|
|
return newQBitArrayFromPointer(C.QBitArray_NewQBitArray2(C.int(size), C.int(qt.GoBoolToInt(value))))
|
|
}
|
|
|
|
func (ptr *QBitArray) At(i int) bool {
|
|
defer qt.Recovering("QBitArray::at")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBitArray_At(ptr.Pointer(), C.int(i)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBitArray) Clear() {
|
|
defer qt.Recovering("QBitArray::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBitArray_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QBitArray) ClearBit(i int) {
|
|
defer qt.Recovering("QBitArray::clearBit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBitArray_ClearBit(ptr.Pointer(), C.int(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBitArray) Count() int {
|
|
defer qt.Recovering("QBitArray::count")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QBitArray_Count(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QBitArray) Count2(on bool) int {
|
|
defer qt.Recovering("QBitArray::count")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QBitArray_Count2(ptr.Pointer(), C.int(qt.GoBoolToInt(on))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QBitArray) Fill(value bool, size int) bool {
|
|
defer qt.Recovering("QBitArray::fill")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBitArray_Fill(ptr.Pointer(), C.int(qt.GoBoolToInt(value)), C.int(size)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBitArray) Fill2(value bool, begin int, end int) {
|
|
defer qt.Recovering("QBitArray::fill")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBitArray_Fill2(ptr.Pointer(), C.int(qt.GoBoolToInt(value)), C.int(begin), C.int(end))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBitArray) IsEmpty() bool {
|
|
defer qt.Recovering("QBitArray::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBitArray_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBitArray) IsNull() bool {
|
|
defer qt.Recovering("QBitArray::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBitArray_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBitArray) Resize(size int) {
|
|
defer qt.Recovering("QBitArray::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBitArray_Resize(ptr.Pointer(), C.int(size))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBitArray) SetBit(i int) {
|
|
defer qt.Recovering("QBitArray::setBit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBitArray_SetBit(ptr.Pointer(), C.int(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBitArray) SetBit2(i int, value bool) {
|
|
defer qt.Recovering("QBitArray::setBit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBitArray_SetBit2(ptr.Pointer(), C.int(i), C.int(qt.GoBoolToInt(value)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBitArray) Size() int {
|
|
defer qt.Recovering("QBitArray::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QBitArray_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QBitArray) Swap(other QBitArray_ITF) {
|
|
defer qt.Recovering("QBitArray::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBitArray_Swap(ptr.Pointer(), PointerFromQBitArray(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBitArray) TestBit(i int) bool {
|
|
defer qt.Recovering("QBitArray::testBit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBitArray_TestBit(ptr.Pointer(), C.int(i)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBitArray) ToggleBit(i int) bool {
|
|
defer qt.Recovering("QBitArray::toggleBit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBitArray_ToggleBit(ptr.Pointer(), C.int(i)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBitArray) Truncate(pos int) {
|
|
defer qt.Recovering("QBitArray::truncate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBitArray_Truncate(ptr.Pointer(), C.int(pos))
|
|
}
|
|
}
|
|
|
|
type QBuffer struct {
|
|
QIODevice
|
|
}
|
|
|
|
type QBuffer_ITF interface {
|
|
QIODevice_ITF
|
|
QBuffer_PTR() *QBuffer
|
|
}
|
|
|
|
func (p *QBuffer) QBuffer_PTR() *QBuffer {
|
|
return p
|
|
}
|
|
|
|
func (p *QBuffer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QIODevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QBuffer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QIODevice_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQBuffer(ptr QBuffer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QBuffer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQBufferFromPointer(ptr unsafe.Pointer) *QBuffer {
|
|
var n = new(QBuffer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQBufferFromPointer(ptr unsafe.Pointer) *QBuffer {
|
|
var n = NewQBufferFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QBuffer_") {
|
|
n.SetObjectName("QBuffer_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQBuffer2(byteArray string, parent QObject_ITF) *QBuffer {
|
|
defer qt.Recovering("QBuffer::QBuffer")
|
|
|
|
return newQBufferFromPointer(C.QBuffer_NewQBuffer2(C.CString(byteArray), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQBuffer(parent QObject_ITF) *QBuffer {
|
|
defer qt.Recovering("QBuffer::QBuffer")
|
|
|
|
return newQBufferFromPointer(C.QBuffer_NewQBuffer(PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQBuffer_AtEnd
|
|
func callbackQBuffer_AtEnd(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QBuffer::atEnd")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "atEnd"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQBufferFromPointer(ptr).AtEndDefault()))
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectAtEnd(f func() bool) {
|
|
defer qt.Recovering("connect QBuffer::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "atEnd", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectAtEnd() {
|
|
defer qt.Recovering("disconnect QBuffer::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "atEnd")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) AtEnd() bool {
|
|
defer qt.Recovering("QBuffer::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_AtEnd(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBuffer) AtEndDefault() bool {
|
|
defer qt.Recovering("QBuffer::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_AtEndDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBuffer) Buffer() string {
|
|
defer qt.Recovering("QBuffer::buffer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QBuffer_Buffer(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QBuffer) Buffer2() string {
|
|
defer qt.Recovering("QBuffer::buffer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QBuffer_Buffer2(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQBuffer_CanReadLine
|
|
func callbackQBuffer_CanReadLine(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QBuffer::canReadLine")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canReadLine"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQBufferFromPointer(ptr).CanReadLineDefault()))
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectCanReadLine(f func() bool) {
|
|
defer qt.Recovering("connect QBuffer::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canReadLine", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectCanReadLine() {
|
|
defer qt.Recovering("disconnect QBuffer::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canReadLine")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) CanReadLine() bool {
|
|
defer qt.Recovering("QBuffer::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_CanReadLine(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBuffer) CanReadLineDefault() bool {
|
|
defer qt.Recovering("QBuffer::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_CanReadLineDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQBuffer_Close
|
|
func callbackQBuffer_Close(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QBuffer::close")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQBufferFromPointer(ptr).CloseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectClose(f func()) {
|
|
defer qt.Recovering("connect QBuffer::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "close", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectClose() {
|
|
defer qt.Recovering("disconnect QBuffer::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "close")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) Close() {
|
|
defer qt.Recovering("QBuffer::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_Close(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) CloseDefault() {
|
|
defer qt.Recovering("QBuffer::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_CloseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) Data() string {
|
|
defer qt.Recovering("QBuffer::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QBuffer_Data(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQBuffer_Open
|
|
func callbackQBuffer_Open(ptr unsafe.Pointer, ptrName *C.char, flags C.int) C.int {
|
|
defer qt.Recovering("callback QBuffer::open")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "open"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(QIODevice__OpenModeFlag) bool)(QIODevice__OpenModeFlag(flags))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQBufferFromPointer(ptr).OpenDefault(QIODevice__OpenModeFlag(flags))))
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectOpen(f func(flags QIODevice__OpenModeFlag) bool) {
|
|
defer qt.Recovering("connect QBuffer::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "open", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectOpen() {
|
|
defer qt.Recovering("disconnect QBuffer::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "open")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) Open(flags QIODevice__OpenModeFlag) bool {
|
|
defer qt.Recovering("QBuffer::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_Open(ptr.Pointer(), C.int(flags)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBuffer) OpenDefault(flags QIODevice__OpenModeFlag) bool {
|
|
defer qt.Recovering("QBuffer::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_OpenDefault(ptr.Pointer(), C.int(flags)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQBuffer_Pos
|
|
func callbackQBuffer_Pos(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QBuffer::pos")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pos"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQBufferFromPointer(ptr).PosDefault())
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectPos(f func() int64) {
|
|
defer qt.Recovering("connect QBuffer::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pos", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectPos() {
|
|
defer qt.Recovering("disconnect QBuffer::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pos")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) Pos() int64 {
|
|
defer qt.Recovering("QBuffer::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QBuffer_Pos(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QBuffer) PosDefault() int64 {
|
|
defer qt.Recovering("QBuffer::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QBuffer_PosDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQBuffer_Seek
|
|
func callbackQBuffer_Seek(ptr unsafe.Pointer, ptrName *C.char, pos C.longlong) C.int {
|
|
defer qt.Recovering("callback QBuffer::seek")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "seek"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int64) bool)(int64(pos))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQBufferFromPointer(ptr).SeekDefault(int64(pos))))
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectSeek(f func(pos int64) bool) {
|
|
defer qt.Recovering("connect QBuffer::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "seek", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectSeek() {
|
|
defer qt.Recovering("disconnect QBuffer::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "seek")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) Seek(pos int64) bool {
|
|
defer qt.Recovering("QBuffer::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_Seek(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBuffer) SeekDefault(pos int64) bool {
|
|
defer qt.Recovering("QBuffer::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_SeekDefault(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBuffer) SetBuffer(byteArray string) {
|
|
defer qt.Recovering("QBuffer::setBuffer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_SetBuffer(ptr.Pointer(), C.CString(byteArray))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) SetData(data string) {
|
|
defer qt.Recovering("QBuffer::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_SetData(ptr.Pointer(), C.CString(data))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) SetData2(data string, size int) {
|
|
defer qt.Recovering("QBuffer::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_SetData2(ptr.Pointer(), C.CString(data), C.int(size))
|
|
}
|
|
}
|
|
|
|
//export callbackQBuffer_Size
|
|
func callbackQBuffer_Size(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QBuffer::size")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "size"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQBufferFromPointer(ptr).SizeDefault())
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectSize(f func() int64) {
|
|
defer qt.Recovering("connect QBuffer::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "size", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectSize() {
|
|
defer qt.Recovering("disconnect QBuffer::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "size")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) Size() int64 {
|
|
defer qt.Recovering("QBuffer::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QBuffer_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QBuffer) SizeDefault() int64 {
|
|
defer qt.Recovering("QBuffer::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QBuffer_SizeDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQBuffer_WriteData
|
|
func callbackQBuffer_WriteData(ptr unsafe.Pointer, ptrName *C.char, data *C.char, len C.longlong) C.longlong {
|
|
defer qt.Recovering("callback QBuffer::writeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "writeData"); signal != nil {
|
|
return C.longlong(signal.(func(string, int64) int64)(C.GoString(data), int64(len)))
|
|
}
|
|
|
|
return C.longlong(NewQBufferFromPointer(ptr).WriteDataDefault(C.GoString(data), int64(len)))
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectWriteData(f func(data string, len int64) int64) {
|
|
defer qt.Recovering("connect QBuffer::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "writeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectWriteData() {
|
|
defer qt.Recovering("disconnect QBuffer::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "writeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) WriteData(data string, len int64) int64 {
|
|
defer qt.Recovering("QBuffer::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QBuffer_WriteData(ptr.Pointer(), C.CString(data), C.longlong(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QBuffer) WriteDataDefault(data string, len int64) int64 {
|
|
defer qt.Recovering("QBuffer::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QBuffer_WriteDataDefault(ptr.Pointer(), C.CString(data), C.longlong(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QBuffer) DestroyQBuffer() {
|
|
defer qt.Recovering("QBuffer::~QBuffer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QBuffer_DestroyQBuffer(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQBuffer_BytesAvailable
|
|
func callbackQBuffer_BytesAvailable(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QBuffer::bytesAvailable")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesAvailable"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQBufferFromPointer(ptr).BytesAvailableDefault())
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectBytesAvailable(f func() int64) {
|
|
defer qt.Recovering("connect QBuffer::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesAvailable", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectBytesAvailable() {
|
|
defer qt.Recovering("disconnect QBuffer::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) BytesAvailable() int64 {
|
|
defer qt.Recovering("QBuffer::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QBuffer_BytesAvailable(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QBuffer) BytesAvailableDefault() int64 {
|
|
defer qt.Recovering("QBuffer::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QBuffer_BytesAvailableDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQBuffer_BytesToWrite
|
|
func callbackQBuffer_BytesToWrite(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QBuffer::bytesToWrite")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesToWrite"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQBufferFromPointer(ptr).BytesToWriteDefault())
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectBytesToWrite(f func() int64) {
|
|
defer qt.Recovering("connect QBuffer::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesToWrite", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectBytesToWrite() {
|
|
defer qt.Recovering("disconnect QBuffer::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesToWrite")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) BytesToWrite() int64 {
|
|
defer qt.Recovering("QBuffer::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QBuffer_BytesToWrite(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QBuffer) BytesToWriteDefault() int64 {
|
|
defer qt.Recovering("QBuffer::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QBuffer_BytesToWriteDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQBuffer_IsSequential
|
|
func callbackQBuffer_IsSequential(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QBuffer::isSequential")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "isSequential"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQBufferFromPointer(ptr).IsSequentialDefault()))
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectIsSequential(f func() bool) {
|
|
defer qt.Recovering("connect QBuffer::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "isSequential", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectIsSequential() {
|
|
defer qt.Recovering("disconnect QBuffer::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "isSequential")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) IsSequential() bool {
|
|
defer qt.Recovering("QBuffer::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_IsSequential(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBuffer) IsSequentialDefault() bool {
|
|
defer qt.Recovering("QBuffer::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_IsSequentialDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQBuffer_ReadLineData
|
|
func callbackQBuffer_ReadLineData(ptr unsafe.Pointer, ptrName *C.char, data *C.char, maxSize C.longlong) C.longlong {
|
|
defer qt.Recovering("callback QBuffer::readLineData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "readLineData"); signal != nil {
|
|
return C.longlong(signal.(func(string, int64) int64)(C.GoString(data), int64(maxSize)))
|
|
}
|
|
|
|
return C.longlong(NewQBufferFromPointer(ptr).ReadLineDataDefault(C.GoString(data), int64(maxSize)))
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectReadLineData(f func(data string, maxSize int64) int64) {
|
|
defer qt.Recovering("connect QBuffer::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "readLineData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectReadLineData() {
|
|
defer qt.Recovering("disconnect QBuffer::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "readLineData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) ReadLineData(data string, maxSize int64) int64 {
|
|
defer qt.Recovering("QBuffer::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QBuffer_ReadLineData(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QBuffer) ReadLineDataDefault(data string, maxSize int64) int64 {
|
|
defer qt.Recovering("QBuffer::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QBuffer_ReadLineDataDefault(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQBuffer_Reset
|
|
func callbackQBuffer_Reset(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QBuffer::reset")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "reset"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQBufferFromPointer(ptr).ResetDefault()))
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectReset(f func() bool) {
|
|
defer qt.Recovering("connect QBuffer::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "reset", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectReset() {
|
|
defer qt.Recovering("disconnect QBuffer::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "reset")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) Reset() bool {
|
|
defer qt.Recovering("QBuffer::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_Reset(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBuffer) ResetDefault() bool {
|
|
defer qt.Recovering("QBuffer::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_ResetDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQBuffer_WaitForBytesWritten
|
|
func callbackQBuffer_WaitForBytesWritten(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) C.int {
|
|
defer qt.Recovering("callback QBuffer::waitForBytesWritten")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "waitForBytesWritten"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(msecs))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQBufferFromPointer(ptr).WaitForBytesWrittenDefault(int(msecs))))
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectWaitForBytesWritten(f func(msecs int) bool) {
|
|
defer qt.Recovering("connect QBuffer::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "waitForBytesWritten", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectWaitForBytesWritten() {
|
|
defer qt.Recovering("disconnect QBuffer::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "waitForBytesWritten")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) WaitForBytesWritten(msecs int) bool {
|
|
defer qt.Recovering("QBuffer::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_WaitForBytesWritten(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBuffer) WaitForBytesWrittenDefault(msecs int) bool {
|
|
defer qt.Recovering("QBuffer::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_WaitForBytesWrittenDefault(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQBuffer_WaitForReadyRead
|
|
func callbackQBuffer_WaitForReadyRead(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) C.int {
|
|
defer qt.Recovering("callback QBuffer::waitForReadyRead")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "waitForReadyRead"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(msecs))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQBufferFromPointer(ptr).WaitForReadyReadDefault(int(msecs))))
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectWaitForReadyRead(f func(msecs int) bool) {
|
|
defer qt.Recovering("connect QBuffer::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "waitForReadyRead", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectWaitForReadyRead() {
|
|
defer qt.Recovering("disconnect QBuffer::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "waitForReadyRead")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) WaitForReadyRead(msecs int) bool {
|
|
defer qt.Recovering("QBuffer::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_WaitForReadyRead(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBuffer) WaitForReadyReadDefault(msecs int) bool {
|
|
defer qt.Recovering("QBuffer::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_WaitForReadyReadDefault(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQBuffer_TimerEvent
|
|
func callbackQBuffer_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QBuffer::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQBufferFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QBuffer::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QBuffer::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QBuffer::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QBuffer::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQBuffer_ChildEvent
|
|
func callbackQBuffer_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QBuffer::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQBufferFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QBuffer::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QBuffer::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QBuffer::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QBuffer::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQBuffer_ConnectNotify
|
|
func callbackQBuffer_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QBuffer::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQBufferFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QBuffer::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QBuffer::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QBuffer::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QBuffer::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQBuffer_CustomEvent
|
|
func callbackQBuffer_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QBuffer::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQBufferFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QBuffer::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QBuffer::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QBuffer::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QBuffer::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQBuffer_DeleteLater
|
|
func callbackQBuffer_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QBuffer::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQBufferFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QBuffer::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QBuffer::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DeleteLater() {
|
|
defer qt.Recovering("QBuffer::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QBuffer_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DeleteLaterDefault() {
|
|
defer qt.Recovering("QBuffer::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QBuffer_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQBuffer_DisconnectNotify
|
|
func callbackQBuffer_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QBuffer::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQBufferFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QBuffer::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QBuffer::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QBuffer::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QBuffer::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QBuffer_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQBuffer_Event
|
|
func callbackQBuffer_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QBuffer::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQBufferFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QBuffer::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QBuffer::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QBuffer::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBuffer) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QBuffer::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQBuffer_EventFilter
|
|
func callbackQBuffer_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QBuffer::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQBufferFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QBuffer::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QBuffer::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QBuffer::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QBuffer) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QBuffer::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QBuffer_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQBuffer_MetaObject
|
|
func callbackQBuffer_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QBuffer::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQBufferFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QBuffer) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QBuffer::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QBuffer::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QBuffer) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QBuffer::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QBuffer_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QBuffer) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QBuffer::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QBuffer_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//QByteArray::Base64Option
|
|
type QByteArray__Base64Option int64
|
|
|
|
const (
|
|
QByteArray__Base64Encoding = QByteArray__Base64Option(0)
|
|
QByteArray__Base64UrlEncoding = QByteArray__Base64Option(1)
|
|
QByteArray__KeepTrailingEquals = QByteArray__Base64Option(0)
|
|
QByteArray__OmitTrailingEquals = QByteArray__Base64Option(2)
|
|
)
|
|
|
|
type QByteArray struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QByteArray_ITF interface {
|
|
QByteArray_PTR() *QByteArray
|
|
}
|
|
|
|
func (p *QByteArray) QByteArray_PTR() *QByteArray {
|
|
return p
|
|
}
|
|
|
|
func (p *QByteArray) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QByteArray) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQByteArray(ptr QByteArray_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QByteArray_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQByteArrayFromPointer(ptr unsafe.Pointer) *QByteArray {
|
|
var n = new(QByteArray)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQByteArrayFromPointer(ptr unsafe.Pointer) *QByteArray {
|
|
var n = NewQByteArrayFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QByteArrayList struct {
|
|
QList
|
|
}
|
|
|
|
type QByteArrayList_ITF interface {
|
|
QList_ITF
|
|
QByteArrayList_PTR() *QByteArrayList
|
|
}
|
|
|
|
func (p *QByteArrayList) QByteArrayList_PTR() *QByteArrayList {
|
|
return p
|
|
}
|
|
|
|
func (p *QByteArrayList) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QList_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QByteArrayList) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QList_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQByteArrayList(ptr QByteArrayList_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QByteArrayList_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQByteArrayListFromPointer(ptr unsafe.Pointer) *QByteArrayList {
|
|
var n = new(QByteArrayList)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQByteArrayListFromPointer(ptr unsafe.Pointer) *QByteArrayList {
|
|
var n = NewQByteArrayListFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QByteArrayList) Join() string {
|
|
defer qt.Recovering("QByteArrayList::join")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QByteArrayList_Join(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QByteArrayList) Join3(separator string) string {
|
|
defer qt.Recovering("QByteArrayList::join")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QByteArrayList_Join3(ptr.Pointer(), C.CString(separator)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QByteArrayList) Join2(separator string) string {
|
|
defer qt.Recovering("QByteArrayList::join")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QByteArrayList_Join2(ptr.Pointer(), C.CString(separator)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type QByteArrayMatcher struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QByteArrayMatcher_ITF interface {
|
|
QByteArrayMatcher_PTR() *QByteArrayMatcher
|
|
}
|
|
|
|
func (p *QByteArrayMatcher) QByteArrayMatcher_PTR() *QByteArrayMatcher {
|
|
return p
|
|
}
|
|
|
|
func (p *QByteArrayMatcher) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QByteArrayMatcher) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQByteArrayMatcher(ptr QByteArrayMatcher_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QByteArrayMatcher_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQByteArrayMatcherFromPointer(ptr unsafe.Pointer) *QByteArrayMatcher {
|
|
var n = new(QByteArrayMatcher)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQByteArrayMatcherFromPointer(ptr unsafe.Pointer) *QByteArrayMatcher {
|
|
var n = NewQByteArrayMatcherFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQByteArrayMatcher() *QByteArrayMatcher {
|
|
defer qt.Recovering("QByteArrayMatcher::QByteArrayMatcher")
|
|
|
|
return newQByteArrayMatcherFromPointer(C.QByteArrayMatcher_NewQByteArrayMatcher())
|
|
}
|
|
|
|
func NewQByteArrayMatcher2(pattern string) *QByteArrayMatcher {
|
|
defer qt.Recovering("QByteArrayMatcher::QByteArrayMatcher")
|
|
|
|
return newQByteArrayMatcherFromPointer(C.QByteArrayMatcher_NewQByteArrayMatcher2(C.CString(pattern)))
|
|
}
|
|
|
|
func NewQByteArrayMatcher4(other QByteArrayMatcher_ITF) *QByteArrayMatcher {
|
|
defer qt.Recovering("QByteArrayMatcher::QByteArrayMatcher")
|
|
|
|
return newQByteArrayMatcherFromPointer(C.QByteArrayMatcher_NewQByteArrayMatcher4(PointerFromQByteArrayMatcher(other)))
|
|
}
|
|
|
|
func NewQByteArrayMatcher3(pattern string, length int) *QByteArrayMatcher {
|
|
defer qt.Recovering("QByteArrayMatcher::QByteArrayMatcher")
|
|
|
|
return newQByteArrayMatcherFromPointer(C.QByteArrayMatcher_NewQByteArrayMatcher3(C.CString(pattern), C.int(length)))
|
|
}
|
|
|
|
func (ptr *QByteArrayMatcher) IndexIn(ba string, from int) int {
|
|
defer qt.Recovering("QByteArrayMatcher::indexIn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QByteArrayMatcher_IndexIn(ptr.Pointer(), C.CString(ba), C.int(from)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QByteArrayMatcher) IndexIn2(str string, len int, from int) int {
|
|
defer qt.Recovering("QByteArrayMatcher::indexIn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QByteArrayMatcher_IndexIn2(ptr.Pointer(), C.CString(str), C.int(len), C.int(from)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QByteArrayMatcher) Pattern() string {
|
|
defer qt.Recovering("QByteArrayMatcher::pattern")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QByteArrayMatcher_Pattern(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QByteArrayMatcher) SetPattern(pattern string) {
|
|
defer qt.Recovering("QByteArrayMatcher::setPattern")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QByteArrayMatcher_SetPattern(ptr.Pointer(), C.CString(pattern))
|
|
}
|
|
}
|
|
|
|
func (ptr *QByteArrayMatcher) DestroyQByteArrayMatcher() {
|
|
defer qt.Recovering("QByteArrayMatcher::~QByteArrayMatcher")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QByteArrayMatcher_DestroyQByteArrayMatcher(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QCache struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QCache_ITF interface {
|
|
QCache_PTR() *QCache
|
|
}
|
|
|
|
func (p *QCache) QCache_PTR() *QCache {
|
|
return p
|
|
}
|
|
|
|
func (p *QCache) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QCache) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQCache(ptr QCache_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCache_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCacheFromPointer(ptr unsafe.Pointer) *QCache {
|
|
var n = new(QCache)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQCacheFromPointer(ptr unsafe.Pointer) *QCache {
|
|
var n = NewQCacheFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QChar::Category
|
|
type QChar__Category int64
|
|
|
|
const (
|
|
QChar__Mark_NonSpacing = QChar__Category(0)
|
|
QChar__Mark_SpacingCombining = QChar__Category(1)
|
|
QChar__Mark_Enclosing = QChar__Category(2)
|
|
QChar__Number_DecimalDigit = QChar__Category(3)
|
|
QChar__Number_Letter = QChar__Category(4)
|
|
QChar__Number_Other = QChar__Category(5)
|
|
QChar__Separator_Space = QChar__Category(6)
|
|
QChar__Separator_Line = QChar__Category(7)
|
|
QChar__Separator_Paragraph = QChar__Category(8)
|
|
QChar__Other_Control = QChar__Category(9)
|
|
QChar__Other_Format = QChar__Category(10)
|
|
QChar__Other_Surrogate = QChar__Category(11)
|
|
QChar__Other_PrivateUse = QChar__Category(12)
|
|
QChar__Other_NotAssigned = QChar__Category(13)
|
|
QChar__Letter_Uppercase = QChar__Category(14)
|
|
QChar__Letter_Lowercase = QChar__Category(15)
|
|
QChar__Letter_Titlecase = QChar__Category(16)
|
|
QChar__Letter_Modifier = QChar__Category(17)
|
|
QChar__Letter_Other = QChar__Category(18)
|
|
QChar__Punctuation_Connector = QChar__Category(19)
|
|
QChar__Punctuation_Dash = QChar__Category(20)
|
|
QChar__Punctuation_Open = QChar__Category(21)
|
|
QChar__Punctuation_Close = QChar__Category(22)
|
|
QChar__Punctuation_InitialQuote = QChar__Category(23)
|
|
QChar__Punctuation_FinalQuote = QChar__Category(24)
|
|
QChar__Punctuation_Other = QChar__Category(25)
|
|
QChar__Symbol_Math = QChar__Category(26)
|
|
QChar__Symbol_Currency = QChar__Category(27)
|
|
QChar__Symbol_Modifier = QChar__Category(28)
|
|
QChar__Symbol_Other = QChar__Category(29)
|
|
)
|
|
|
|
//QChar::Decomposition
|
|
type QChar__Decomposition int64
|
|
|
|
const (
|
|
QChar__NoDecomposition = QChar__Decomposition(0)
|
|
QChar__Canonical = QChar__Decomposition(1)
|
|
QChar__Font = QChar__Decomposition(2)
|
|
QChar__NoBreak = QChar__Decomposition(3)
|
|
QChar__Initial = QChar__Decomposition(4)
|
|
QChar__Medial = QChar__Decomposition(5)
|
|
QChar__Final = QChar__Decomposition(6)
|
|
QChar__Isolated = QChar__Decomposition(7)
|
|
QChar__Circle = QChar__Decomposition(8)
|
|
QChar__Super = QChar__Decomposition(9)
|
|
QChar__Sub = QChar__Decomposition(10)
|
|
QChar__Vertical = QChar__Decomposition(11)
|
|
QChar__Wide = QChar__Decomposition(12)
|
|
QChar__Narrow = QChar__Decomposition(13)
|
|
QChar__Small = QChar__Decomposition(14)
|
|
QChar__Square = QChar__Decomposition(15)
|
|
QChar__Compat = QChar__Decomposition(16)
|
|
QChar__Fraction = QChar__Decomposition(17)
|
|
)
|
|
|
|
//QChar::Direction
|
|
type QChar__Direction int64
|
|
|
|
const (
|
|
QChar__DirL = QChar__Direction(0)
|
|
QChar__DirR = QChar__Direction(1)
|
|
QChar__DirEN = QChar__Direction(2)
|
|
QChar__DirES = QChar__Direction(3)
|
|
QChar__DirET = QChar__Direction(4)
|
|
QChar__DirAN = QChar__Direction(5)
|
|
QChar__DirCS = QChar__Direction(6)
|
|
QChar__DirB = QChar__Direction(7)
|
|
QChar__DirS = QChar__Direction(8)
|
|
QChar__DirWS = QChar__Direction(9)
|
|
QChar__DirON = QChar__Direction(10)
|
|
QChar__DirLRE = QChar__Direction(11)
|
|
QChar__DirLRO = QChar__Direction(12)
|
|
QChar__DirAL = QChar__Direction(13)
|
|
QChar__DirRLE = QChar__Direction(14)
|
|
QChar__DirRLO = QChar__Direction(15)
|
|
QChar__DirPDF = QChar__Direction(16)
|
|
QChar__DirNSM = QChar__Direction(17)
|
|
QChar__DirBN = QChar__Direction(18)
|
|
QChar__DirLRI = QChar__Direction(19)
|
|
QChar__DirRLI = QChar__Direction(20)
|
|
QChar__DirFSI = QChar__Direction(21)
|
|
QChar__DirPDI = QChar__Direction(22)
|
|
)
|
|
|
|
//QChar::JoiningType
|
|
type QChar__JoiningType int64
|
|
|
|
const (
|
|
QChar__Joining_None = QChar__JoiningType(0)
|
|
QChar__Joining_Causing = QChar__JoiningType(1)
|
|
QChar__Joining_Dual = QChar__JoiningType(2)
|
|
QChar__Joining_Right = QChar__JoiningType(3)
|
|
QChar__Joining_Left = QChar__JoiningType(4)
|
|
QChar__Joining_Transparent = QChar__JoiningType(5)
|
|
)
|
|
|
|
//QChar::Script
|
|
type QChar__Script int64
|
|
|
|
const (
|
|
QChar__Script_Unknown = QChar__Script(0)
|
|
QChar__Script_Inherited = QChar__Script(1)
|
|
QChar__Script_Common = QChar__Script(2)
|
|
QChar__Script_Latin = QChar__Script(3)
|
|
QChar__Script_Greek = QChar__Script(4)
|
|
QChar__Script_Cyrillic = QChar__Script(5)
|
|
QChar__Script_Armenian = QChar__Script(6)
|
|
QChar__Script_Hebrew = QChar__Script(7)
|
|
QChar__Script_Arabic = QChar__Script(8)
|
|
QChar__Script_Syriac = QChar__Script(9)
|
|
QChar__Script_Thaana = QChar__Script(10)
|
|
QChar__Script_Devanagari = QChar__Script(11)
|
|
QChar__Script_Bengali = QChar__Script(12)
|
|
QChar__Script_Gurmukhi = QChar__Script(13)
|
|
QChar__Script_Gujarati = QChar__Script(14)
|
|
QChar__Script_Oriya = QChar__Script(15)
|
|
QChar__Script_Tamil = QChar__Script(16)
|
|
QChar__Script_Telugu = QChar__Script(17)
|
|
QChar__Script_Kannada = QChar__Script(18)
|
|
QChar__Script_Malayalam = QChar__Script(19)
|
|
QChar__Script_Sinhala = QChar__Script(20)
|
|
QChar__Script_Thai = QChar__Script(21)
|
|
QChar__Script_Lao = QChar__Script(22)
|
|
QChar__Script_Tibetan = QChar__Script(23)
|
|
QChar__Script_Myanmar = QChar__Script(24)
|
|
QChar__Script_Georgian = QChar__Script(25)
|
|
QChar__Script_Hangul = QChar__Script(26)
|
|
QChar__Script_Ethiopic = QChar__Script(27)
|
|
QChar__Script_Cherokee = QChar__Script(28)
|
|
QChar__Script_CanadianAboriginal = QChar__Script(29)
|
|
QChar__Script_Ogham = QChar__Script(30)
|
|
QChar__Script_Runic = QChar__Script(31)
|
|
QChar__Script_Khmer = QChar__Script(32)
|
|
QChar__Script_Mongolian = QChar__Script(33)
|
|
QChar__Script_Hiragana = QChar__Script(34)
|
|
QChar__Script_Katakana = QChar__Script(35)
|
|
QChar__Script_Bopomofo = QChar__Script(36)
|
|
QChar__Script_Han = QChar__Script(37)
|
|
QChar__Script_Yi = QChar__Script(38)
|
|
QChar__Script_OldItalic = QChar__Script(39)
|
|
QChar__Script_Gothic = QChar__Script(40)
|
|
QChar__Script_Deseret = QChar__Script(41)
|
|
QChar__Script_Tagalog = QChar__Script(42)
|
|
QChar__Script_Hanunoo = QChar__Script(43)
|
|
QChar__Script_Buhid = QChar__Script(44)
|
|
QChar__Script_Tagbanwa = QChar__Script(45)
|
|
QChar__Script_Coptic = QChar__Script(46)
|
|
QChar__Script_Limbu = QChar__Script(47)
|
|
QChar__Script_TaiLe = QChar__Script(48)
|
|
QChar__Script_LinearB = QChar__Script(49)
|
|
QChar__Script_Ugaritic = QChar__Script(50)
|
|
QChar__Script_Shavian = QChar__Script(51)
|
|
QChar__Script_Osmanya = QChar__Script(52)
|
|
QChar__Script_Cypriot = QChar__Script(53)
|
|
QChar__Script_Braille = QChar__Script(54)
|
|
QChar__Script_Buginese = QChar__Script(55)
|
|
QChar__Script_NewTaiLue = QChar__Script(56)
|
|
QChar__Script_Glagolitic = QChar__Script(57)
|
|
QChar__Script_Tifinagh = QChar__Script(58)
|
|
QChar__Script_SylotiNagri = QChar__Script(59)
|
|
QChar__Script_OldPersian = QChar__Script(60)
|
|
QChar__Script_Kharoshthi = QChar__Script(61)
|
|
QChar__Script_Balinese = QChar__Script(62)
|
|
QChar__Script_Cuneiform = QChar__Script(63)
|
|
QChar__Script_Phoenician = QChar__Script(64)
|
|
QChar__Script_PhagsPa = QChar__Script(65)
|
|
QChar__Script_Nko = QChar__Script(66)
|
|
QChar__Script_Sundanese = QChar__Script(67)
|
|
QChar__Script_Lepcha = QChar__Script(68)
|
|
QChar__Script_OlChiki = QChar__Script(69)
|
|
QChar__Script_Vai = QChar__Script(70)
|
|
QChar__Script_Saurashtra = QChar__Script(71)
|
|
QChar__Script_KayahLi = QChar__Script(72)
|
|
QChar__Script_Rejang = QChar__Script(73)
|
|
QChar__Script_Lycian = QChar__Script(74)
|
|
QChar__Script_Carian = QChar__Script(75)
|
|
QChar__Script_Lydian = QChar__Script(76)
|
|
QChar__Script_Cham = QChar__Script(77)
|
|
QChar__Script_TaiTham = QChar__Script(78)
|
|
QChar__Script_TaiViet = QChar__Script(79)
|
|
QChar__Script_Avestan = QChar__Script(80)
|
|
QChar__Script_EgyptianHieroglyphs = QChar__Script(81)
|
|
QChar__Script_Samaritan = QChar__Script(82)
|
|
QChar__Script_Lisu = QChar__Script(83)
|
|
QChar__Script_Bamum = QChar__Script(84)
|
|
QChar__Script_Javanese = QChar__Script(85)
|
|
QChar__Script_MeeteiMayek = QChar__Script(86)
|
|
QChar__Script_ImperialAramaic = QChar__Script(87)
|
|
QChar__Script_OldSouthArabian = QChar__Script(88)
|
|
QChar__Script_InscriptionalParthian = QChar__Script(89)
|
|
QChar__Script_InscriptionalPahlavi = QChar__Script(90)
|
|
QChar__Script_OldTurkic = QChar__Script(91)
|
|
QChar__Script_Kaithi = QChar__Script(92)
|
|
QChar__Script_Batak = QChar__Script(93)
|
|
QChar__Script_Brahmi = QChar__Script(94)
|
|
QChar__Script_Mandaic = QChar__Script(95)
|
|
QChar__Script_Chakma = QChar__Script(96)
|
|
QChar__Script_MeroiticCursive = QChar__Script(97)
|
|
QChar__Script_MeroiticHieroglyphs = QChar__Script(98)
|
|
QChar__Script_Miao = QChar__Script(99)
|
|
QChar__Script_Sharada = QChar__Script(100)
|
|
QChar__Script_SoraSompeng = QChar__Script(101)
|
|
QChar__Script_Takri = QChar__Script(102)
|
|
QChar__Script_CaucasianAlbanian = QChar__Script(103)
|
|
QChar__Script_BassaVah = QChar__Script(104)
|
|
QChar__Script_Duployan = QChar__Script(105)
|
|
QChar__Script_Elbasan = QChar__Script(106)
|
|
QChar__Script_Grantha = QChar__Script(107)
|
|
QChar__Script_PahawhHmong = QChar__Script(108)
|
|
QChar__Script_Khojki = QChar__Script(109)
|
|
QChar__Script_LinearA = QChar__Script(110)
|
|
QChar__Script_Mahajani = QChar__Script(111)
|
|
QChar__Script_Manichaean = QChar__Script(112)
|
|
QChar__Script_MendeKikakui = QChar__Script(113)
|
|
QChar__Script_Modi = QChar__Script(114)
|
|
QChar__Script_Mro = QChar__Script(115)
|
|
QChar__Script_OldNorthArabian = QChar__Script(116)
|
|
QChar__Script_Nabataean = QChar__Script(117)
|
|
QChar__Script_Palmyrene = QChar__Script(118)
|
|
QChar__Script_PauCinHau = QChar__Script(119)
|
|
QChar__Script_OldPermic = QChar__Script(120)
|
|
QChar__Script_PsalterPahlavi = QChar__Script(121)
|
|
QChar__Script_Siddham = QChar__Script(122)
|
|
QChar__Script_Khudawadi = QChar__Script(123)
|
|
QChar__Script_Tirhuta = QChar__Script(124)
|
|
QChar__Script_WarangCiti = QChar__Script(125)
|
|
QChar__Script_Ahom = QChar__Script(126)
|
|
QChar__Script_AnatolianHieroglyphs = QChar__Script(127)
|
|
QChar__Script_Hatran = QChar__Script(128)
|
|
QChar__Script_Multani = QChar__Script(129)
|
|
QChar__Script_OldHungarian = QChar__Script(130)
|
|
QChar__Script_SignWriting = QChar__Script(131)
|
|
QChar__ScriptCount = QChar__Script(132)
|
|
)
|
|
|
|
//QChar::SpecialCharacter
|
|
type QChar__SpecialCharacter int64
|
|
|
|
const (
|
|
QChar__Null = QChar__SpecialCharacter(0x0000)
|
|
QChar__Tabulation = QChar__SpecialCharacter(0x0009)
|
|
QChar__LineFeed = QChar__SpecialCharacter(0x000a)
|
|
QChar__CarriageReturn = QChar__SpecialCharacter(0x000d)
|
|
QChar__Space = QChar__SpecialCharacter(0x0020)
|
|
QChar__Nbsp = QChar__SpecialCharacter(0x00a0)
|
|
QChar__SoftHyphen = QChar__SpecialCharacter(0x00ad)
|
|
QChar__ReplacementCharacter = QChar__SpecialCharacter(0xfffd)
|
|
QChar__ObjectReplacementCharacter = QChar__SpecialCharacter(0xfffc)
|
|
QChar__ByteOrderMark = QChar__SpecialCharacter(0xfeff)
|
|
QChar__ByteOrderSwapped = QChar__SpecialCharacter(0xfffe)
|
|
QChar__ParagraphSeparator = QChar__SpecialCharacter(0x2029)
|
|
QChar__LineSeparator = QChar__SpecialCharacter(0x2028)
|
|
QChar__LastValidCodePoint = QChar__SpecialCharacter(0x10ffff)
|
|
)
|
|
|
|
//QChar::UnicodeVersion
|
|
type QChar__UnicodeVersion int64
|
|
|
|
const (
|
|
QChar__Unicode_Unassigned = QChar__UnicodeVersion(0)
|
|
QChar__Unicode_1_1 = QChar__UnicodeVersion(1)
|
|
QChar__Unicode_2_0 = QChar__UnicodeVersion(2)
|
|
QChar__Unicode_2_1_2 = QChar__UnicodeVersion(3)
|
|
QChar__Unicode_3_0 = QChar__UnicodeVersion(4)
|
|
QChar__Unicode_3_1 = QChar__UnicodeVersion(5)
|
|
QChar__Unicode_3_2 = QChar__UnicodeVersion(6)
|
|
QChar__Unicode_4_0 = QChar__UnicodeVersion(7)
|
|
QChar__Unicode_4_1 = QChar__UnicodeVersion(8)
|
|
QChar__Unicode_5_0 = QChar__UnicodeVersion(9)
|
|
QChar__Unicode_5_1 = QChar__UnicodeVersion(10)
|
|
QChar__Unicode_5_2 = QChar__UnicodeVersion(11)
|
|
QChar__Unicode_6_0 = QChar__UnicodeVersion(12)
|
|
QChar__Unicode_6_1 = QChar__UnicodeVersion(13)
|
|
QChar__Unicode_6_2 = QChar__UnicodeVersion(14)
|
|
QChar__Unicode_6_3 = QChar__UnicodeVersion(15)
|
|
QChar__Unicode_7_0 = QChar__UnicodeVersion(16)
|
|
QChar__Unicode_8_0 = QChar__UnicodeVersion(17)
|
|
)
|
|
|
|
type QChar struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QChar_ITF interface {
|
|
QChar_PTR() *QChar
|
|
}
|
|
|
|
func (p *QChar) QChar_PTR() *QChar {
|
|
return p
|
|
}
|
|
|
|
func (p *QChar) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QChar) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQChar(ptr QChar_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QChar_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCharFromPointer(ptr unsafe.Pointer) *QChar {
|
|
var n = new(QChar)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQCharFromPointer(ptr unsafe.Pointer) *QChar {
|
|
var n = NewQCharFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQChar() *QChar {
|
|
defer qt.Recovering("QChar::QChar")
|
|
|
|
return newQCharFromPointer(C.QChar_NewQChar())
|
|
}
|
|
|
|
func NewQChar8(ch QLatin1Char_ITF) *QChar {
|
|
defer qt.Recovering("QChar::QChar")
|
|
|
|
return newQCharFromPointer(C.QChar_NewQChar8(PointerFromQLatin1Char(ch)))
|
|
}
|
|
|
|
func NewQChar7(ch QChar__SpecialCharacter) *QChar {
|
|
defer qt.Recovering("QChar::QChar")
|
|
|
|
return newQCharFromPointer(C.QChar_NewQChar7(C.int(ch)))
|
|
}
|
|
|
|
func NewQChar9(ch string) *QChar {
|
|
defer qt.Recovering("QChar::QChar")
|
|
|
|
return newQCharFromPointer(C.QChar_NewQChar9(C.CString(ch)))
|
|
}
|
|
|
|
func NewQChar6(code int) *QChar {
|
|
defer qt.Recovering("QChar::QChar")
|
|
|
|
return newQCharFromPointer(C.QChar_NewQChar6(C.int(code)))
|
|
}
|
|
|
|
func (ptr *QChar) Category() QChar__Category {
|
|
defer qt.Recovering("QChar::category")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QChar__Category(C.QChar_Category(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QChar_CurrentUnicodeVersion() QChar__UnicodeVersion {
|
|
defer qt.Recovering("QChar::currentUnicodeVersion")
|
|
|
|
return QChar__UnicodeVersion(C.QChar_QChar_CurrentUnicodeVersion())
|
|
}
|
|
|
|
func (ptr *QChar) CurrentUnicodeVersion() QChar__UnicodeVersion {
|
|
defer qt.Recovering("QChar::currentUnicodeVersion")
|
|
|
|
return QChar__UnicodeVersion(C.QChar_QChar_CurrentUnicodeVersion())
|
|
}
|
|
|
|
func (ptr *QChar) Decomposition() string {
|
|
defer qt.Recovering("QChar::decomposition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QChar_Decomposition(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QChar) DecompositionTag() QChar__Decomposition {
|
|
defer qt.Recovering("QChar::decompositionTag")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QChar__Decomposition(C.QChar_DecompositionTag(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QChar) DigitValue() int {
|
|
defer qt.Recovering("QChar::digitValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QChar_DigitValue(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QChar) Direction() QChar__Direction {
|
|
defer qt.Recovering("QChar::direction")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QChar__Direction(C.QChar_Direction(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QChar) HasMirrored() bool {
|
|
defer qt.Recovering("QChar::hasMirrored")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_HasMirrored(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsDigit() bool {
|
|
defer qt.Recovering("QChar::isDigit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsDigit(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsHighSurrogate() bool {
|
|
defer qt.Recovering("QChar::isHighSurrogate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsHighSurrogate(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsLetter() bool {
|
|
defer qt.Recovering("QChar::isLetter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsLetter(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsLetterOrNumber() bool {
|
|
defer qt.Recovering("QChar::isLetterOrNumber")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsLetterOrNumber(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsLower() bool {
|
|
defer qt.Recovering("QChar::isLower")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsLower(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsLowSurrogate() bool {
|
|
defer qt.Recovering("QChar::isLowSurrogate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsLowSurrogate(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsMark() bool {
|
|
defer qt.Recovering("QChar::isMark")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsMark(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsNonCharacter() bool {
|
|
defer qt.Recovering("QChar::isNonCharacter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsNonCharacter(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsNull() bool {
|
|
defer qt.Recovering("QChar::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsNumber() bool {
|
|
defer qt.Recovering("QChar::isNumber")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsNumber(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsPrint() bool {
|
|
defer qt.Recovering("QChar::isPrint")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsPrint(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsPunct() bool {
|
|
defer qt.Recovering("QChar::isPunct")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsPunct(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsSpace() bool {
|
|
defer qt.Recovering("QChar::isSpace")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsSpace(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsSurrogate() bool {
|
|
defer qt.Recovering("QChar::isSurrogate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsSurrogate(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsSymbol() bool {
|
|
defer qt.Recovering("QChar::isSymbol")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsSymbol(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsTitleCase() bool {
|
|
defer qt.Recovering("QChar::isTitleCase")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsTitleCase(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) IsUpper() bool {
|
|
defer qt.Recovering("QChar::isUpper")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChar_IsUpper(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChar) JoiningType() QChar__JoiningType {
|
|
defer qt.Recovering("QChar::joiningType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QChar__JoiningType(C.QChar_JoiningType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QChar) Script() QChar__Script {
|
|
defer qt.Recovering("QChar::script")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QChar__Script(C.QChar_Script(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QChar) ToLatin1() string {
|
|
defer qt.Recovering("QChar::toLatin1")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QChar_ToLatin1(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QChar) UnicodeVersion() QChar__UnicodeVersion {
|
|
defer qt.Recovering("QChar::unicodeVersion")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QChar__UnicodeVersion(C.QChar_UnicodeVersion(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QChildEvent struct {
|
|
QEvent
|
|
}
|
|
|
|
type QChildEvent_ITF interface {
|
|
QEvent_ITF
|
|
QChildEvent_PTR() *QChildEvent
|
|
}
|
|
|
|
func (p *QChildEvent) QChildEvent_PTR() *QChildEvent {
|
|
return p
|
|
}
|
|
|
|
func (p *QChildEvent) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QEvent_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QChildEvent) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QEvent_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQChildEvent(ptr QChildEvent_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QChildEvent_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQChildEventFromPointer(ptr unsafe.Pointer) *QChildEvent {
|
|
var n = new(QChildEvent)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQChildEventFromPointer(ptr unsafe.Pointer) *QChildEvent {
|
|
var n = NewQChildEventFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQChildEvent(ty QEvent__Type, child QObject_ITF) *QChildEvent {
|
|
defer qt.Recovering("QChildEvent::QChildEvent")
|
|
|
|
return newQChildEventFromPointer(C.QChildEvent_NewQChildEvent(C.int(ty), PointerFromQObject(child)))
|
|
}
|
|
|
|
func (ptr *QChildEvent) Added() bool {
|
|
defer qt.Recovering("QChildEvent::added")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChildEvent_Added(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChildEvent) Child() *QObject {
|
|
defer qt.Recovering("QChildEvent::child")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QChildEvent_Child(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QChildEvent) Polished() bool {
|
|
defer qt.Recovering("QChildEvent::polished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChildEvent_Polished(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChildEvent) Removed() bool {
|
|
defer qt.Recovering("QChildEvent::removed")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QChildEvent_Removed(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QChildEvent) C() *QObject {
|
|
defer qt.Recovering("QChildEvent::c")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QChildEvent_C(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QChildEvent) SetC(vqo QObject_ITF) {
|
|
defer qt.Recovering("QChildEvent::setC")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QChildEvent_SetC(ptr.Pointer(), PointerFromQObject(vqo))
|
|
}
|
|
}
|
|
|
|
type QCollator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QCollator_ITF interface {
|
|
QCollator_PTR() *QCollator
|
|
}
|
|
|
|
func (p *QCollator) QCollator_PTR() *QCollator {
|
|
return p
|
|
}
|
|
|
|
func (p *QCollator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QCollator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQCollator(ptr QCollator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCollator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCollatorFromPointer(ptr unsafe.Pointer) *QCollator {
|
|
var n = new(QCollator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQCollatorFromPointer(ptr unsafe.Pointer) *QCollator {
|
|
var n = NewQCollatorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QCollator) CaseSensitivity() Qt__CaseSensitivity {
|
|
defer qt.Recovering("QCollator::caseSensitivity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__CaseSensitivity(C.QCollator_CaseSensitivity(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCollator) IgnorePunctuation() bool {
|
|
defer qt.Recovering("QCollator::ignorePunctuation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QCollator_IgnorePunctuation(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCollator) NumericMode() bool {
|
|
defer qt.Recovering("QCollator::numericMode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QCollator_NumericMode(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCollator) SetCaseSensitivity(sensitivity Qt__CaseSensitivity) {
|
|
defer qt.Recovering("QCollator::setCaseSensitivity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCollator_SetCaseSensitivity(ptr.Pointer(), C.int(sensitivity))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCollator) SetIgnorePunctuation(on bool) {
|
|
defer qt.Recovering("QCollator::setIgnorePunctuation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCollator_SetIgnorePunctuation(ptr.Pointer(), C.int(qt.GoBoolToInt(on)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCollator) SetNumericMode(on bool) {
|
|
defer qt.Recovering("QCollator::setNumericMode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCollator_SetNumericMode(ptr.Pointer(), C.int(qt.GoBoolToInt(on)))
|
|
}
|
|
}
|
|
|
|
func NewQCollator3(other QCollator_ITF) *QCollator {
|
|
defer qt.Recovering("QCollator::QCollator")
|
|
|
|
return newQCollatorFromPointer(C.QCollator_NewQCollator3(PointerFromQCollator(other)))
|
|
}
|
|
|
|
func NewQCollator2(other QCollator_ITF) *QCollator {
|
|
defer qt.Recovering("QCollator::QCollator")
|
|
|
|
return newQCollatorFromPointer(C.QCollator_NewQCollator2(PointerFromQCollator(other)))
|
|
}
|
|
|
|
func NewQCollator(locale QLocale_ITF) *QCollator {
|
|
defer qt.Recovering("QCollator::QCollator")
|
|
|
|
return newQCollatorFromPointer(C.QCollator_NewQCollator(PointerFromQLocale(locale)))
|
|
}
|
|
|
|
func (ptr *QCollator) Locale() *QLocale {
|
|
defer qt.Recovering("QCollator::locale")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLocaleFromPointer(C.QCollator_Locale(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCollator) SetLocale(locale QLocale_ITF) {
|
|
defer qt.Recovering("QCollator::setLocale")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCollator_SetLocale(ptr.Pointer(), PointerFromQLocale(locale))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCollator) Swap(other QCollator_ITF) {
|
|
defer qt.Recovering("QCollator::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCollator_Swap(ptr.Pointer(), PointerFromQCollator(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCollator) DestroyQCollator() {
|
|
defer qt.Recovering("QCollator::~QCollator")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCollator_DestroyQCollator(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCollator) Compare3(s1 QChar_ITF, len1 int, s2 QChar_ITF, len2 int) int {
|
|
defer qt.Recovering("QCollator::compare")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QCollator_Compare3(ptr.Pointer(), PointerFromQChar(s1), C.int(len1), PointerFromQChar(s2), C.int(len2)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCollator) Compare(s1 string, s2 string) int {
|
|
defer qt.Recovering("QCollator::compare")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QCollator_Compare(ptr.Pointer(), C.CString(s1), C.CString(s2)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCollator) Compare2(s1 QStringRef_ITF, s2 QStringRef_ITF) int {
|
|
defer qt.Recovering("QCollator::compare")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QCollator_Compare2(ptr.Pointer(), PointerFromQStringRef(s1), PointerFromQStringRef(s2)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCollator) SortKey(stri string) *QCollatorSortKey {
|
|
defer qt.Recovering("QCollator::sortKey")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQCollatorSortKeyFromPointer(C.QCollator_SortKey(ptr.Pointer(), C.CString(stri)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QCollatorSortKey struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QCollatorSortKey_ITF interface {
|
|
QCollatorSortKey_PTR() *QCollatorSortKey
|
|
}
|
|
|
|
func (p *QCollatorSortKey) QCollatorSortKey_PTR() *QCollatorSortKey {
|
|
return p
|
|
}
|
|
|
|
func (p *QCollatorSortKey) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QCollatorSortKey) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQCollatorSortKey(ptr QCollatorSortKey_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCollatorSortKey_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCollatorSortKeyFromPointer(ptr unsafe.Pointer) *QCollatorSortKey {
|
|
var n = new(QCollatorSortKey)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQCollatorSortKeyFromPointer(ptr unsafe.Pointer) *QCollatorSortKey {
|
|
var n = NewQCollatorSortKeyFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQCollatorSortKey(other QCollatorSortKey_ITF) *QCollatorSortKey {
|
|
defer qt.Recovering("QCollatorSortKey::QCollatorSortKey")
|
|
|
|
return newQCollatorSortKeyFromPointer(C.QCollatorSortKey_NewQCollatorSortKey(PointerFromQCollatorSortKey(other)))
|
|
}
|
|
|
|
func (ptr *QCollatorSortKey) Swap(other QCollatorSortKey_ITF) {
|
|
defer qt.Recovering("QCollatorSortKey::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCollatorSortKey_Swap(ptr.Pointer(), PointerFromQCollatorSortKey(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCollatorSortKey) DestroyQCollatorSortKey() {
|
|
defer qt.Recovering("QCollatorSortKey::~QCollatorSortKey")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCollatorSortKey_DestroyQCollatorSortKey(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCollatorSortKey) Compare(otherKey QCollatorSortKey_ITF) int {
|
|
defer qt.Recovering("QCollatorSortKey::compare")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QCollatorSortKey_Compare(ptr.Pointer(), PointerFromQCollatorSortKey(otherKey)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QCommandLineOption struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QCommandLineOption_ITF interface {
|
|
QCommandLineOption_PTR() *QCommandLineOption
|
|
}
|
|
|
|
func (p *QCommandLineOption) QCommandLineOption_PTR() *QCommandLineOption {
|
|
return p
|
|
}
|
|
|
|
func (p *QCommandLineOption) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QCommandLineOption) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQCommandLineOption(ptr QCommandLineOption_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCommandLineOption_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCommandLineOptionFromPointer(ptr unsafe.Pointer) *QCommandLineOption {
|
|
var n = new(QCommandLineOption)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQCommandLineOptionFromPointer(ptr unsafe.Pointer) *QCommandLineOption {
|
|
var n = NewQCommandLineOptionFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQCommandLineOption5(other QCommandLineOption_ITF) *QCommandLineOption {
|
|
defer qt.Recovering("QCommandLineOption::QCommandLineOption")
|
|
|
|
return newQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption5(PointerFromQCommandLineOption(other)))
|
|
}
|
|
|
|
func NewQCommandLineOption(name string) *QCommandLineOption {
|
|
defer qt.Recovering("QCommandLineOption::QCommandLineOption")
|
|
|
|
return newQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption(C.CString(name)))
|
|
}
|
|
|
|
func NewQCommandLineOption3(name string, description string, valueName string, defaultValue string) *QCommandLineOption {
|
|
defer qt.Recovering("QCommandLineOption::QCommandLineOption")
|
|
|
|
return newQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption3(C.CString(name), C.CString(description), C.CString(valueName), C.CString(defaultValue)))
|
|
}
|
|
|
|
func NewQCommandLineOption2(names []string) *QCommandLineOption {
|
|
defer qt.Recovering("QCommandLineOption::QCommandLineOption")
|
|
|
|
return newQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption2(C.CString(strings.Join(names, "|"))))
|
|
}
|
|
|
|
func NewQCommandLineOption4(names []string, description string, valueName string, defaultValue string) *QCommandLineOption {
|
|
defer qt.Recovering("QCommandLineOption::QCommandLineOption")
|
|
|
|
return newQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption4(C.CString(strings.Join(names, "|")), C.CString(description), C.CString(valueName), C.CString(defaultValue)))
|
|
}
|
|
|
|
func (ptr *QCommandLineOption) DefaultValues() []string {
|
|
defer qt.Recovering("QCommandLineOption::defaultValues")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QCommandLineOption_DefaultValues(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QCommandLineOption) Description() string {
|
|
defer qt.Recovering("QCommandLineOption::description")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QCommandLineOption_Description(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCommandLineOption) IsHidden() bool {
|
|
defer qt.Recovering("QCommandLineOption::isHidden")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QCommandLineOption_IsHidden(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCommandLineOption) Names() []string {
|
|
defer qt.Recovering("QCommandLineOption::names")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QCommandLineOption_Names(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QCommandLineOption) SetDefaultValue(defaultValue string) {
|
|
defer qt.Recovering("QCommandLineOption::setDefaultValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineOption_SetDefaultValue(ptr.Pointer(), C.CString(defaultValue))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineOption) SetDefaultValues(defaultValues []string) {
|
|
defer qt.Recovering("QCommandLineOption::setDefaultValues")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineOption_SetDefaultValues(ptr.Pointer(), C.CString(strings.Join(defaultValues, "|")))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineOption) SetDescription(description string) {
|
|
defer qt.Recovering("QCommandLineOption::setDescription")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineOption_SetDescription(ptr.Pointer(), C.CString(description))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineOption) SetHidden(hide bool) {
|
|
defer qt.Recovering("QCommandLineOption::setHidden")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineOption_SetHidden(ptr.Pointer(), C.int(qt.GoBoolToInt(hide)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineOption) SetValueName(valueName string) {
|
|
defer qt.Recovering("QCommandLineOption::setValueName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineOption_SetValueName(ptr.Pointer(), C.CString(valueName))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineOption) Swap(other QCommandLineOption_ITF) {
|
|
defer qt.Recovering("QCommandLineOption::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineOption_Swap(ptr.Pointer(), PointerFromQCommandLineOption(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineOption) ValueName() string {
|
|
defer qt.Recovering("QCommandLineOption::valueName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QCommandLineOption_ValueName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCommandLineOption) DestroyQCommandLineOption() {
|
|
defer qt.Recovering("QCommandLineOption::~QCommandLineOption")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineOption_DestroyQCommandLineOption(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QCommandLineParser::OptionsAfterPositionalArgumentsMode
|
|
type QCommandLineParser__OptionsAfterPositionalArgumentsMode int64
|
|
|
|
const (
|
|
QCommandLineParser__ParseAsOptions = QCommandLineParser__OptionsAfterPositionalArgumentsMode(0)
|
|
QCommandLineParser__ParseAsPositionalArguments = QCommandLineParser__OptionsAfterPositionalArgumentsMode(1)
|
|
)
|
|
|
|
//QCommandLineParser::SingleDashWordOptionMode
|
|
type QCommandLineParser__SingleDashWordOptionMode int64
|
|
|
|
const (
|
|
QCommandLineParser__ParseAsCompactedShortOptions = QCommandLineParser__SingleDashWordOptionMode(0)
|
|
QCommandLineParser__ParseAsLongOptions = QCommandLineParser__SingleDashWordOptionMode(1)
|
|
)
|
|
|
|
type QCommandLineParser struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QCommandLineParser_ITF interface {
|
|
QCommandLineParser_PTR() *QCommandLineParser
|
|
}
|
|
|
|
func (p *QCommandLineParser) QCommandLineParser_PTR() *QCommandLineParser {
|
|
return p
|
|
}
|
|
|
|
func (p *QCommandLineParser) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QCommandLineParser) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQCommandLineParser(ptr QCommandLineParser_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCommandLineParser_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCommandLineParserFromPointer(ptr unsafe.Pointer) *QCommandLineParser {
|
|
var n = new(QCommandLineParser)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQCommandLineParserFromPointer(ptr unsafe.Pointer) *QCommandLineParser {
|
|
var n = NewQCommandLineParserFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQCommandLineParser() *QCommandLineParser {
|
|
defer qt.Recovering("QCommandLineParser::QCommandLineParser")
|
|
|
|
return newQCommandLineParserFromPointer(C.QCommandLineParser_NewQCommandLineParser())
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) AddHelpOption() *QCommandLineOption {
|
|
defer qt.Recovering("QCommandLineParser::addHelpOption")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQCommandLineOptionFromPointer(C.QCommandLineParser_AddHelpOption(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) AddOption(option QCommandLineOption_ITF) bool {
|
|
defer qt.Recovering("QCommandLineParser::addOption")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QCommandLineParser_AddOption(ptr.Pointer(), PointerFromQCommandLineOption(option)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) AddPositionalArgument(name string, description string, syntax string) {
|
|
defer qt.Recovering("QCommandLineParser::addPositionalArgument")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineParser_AddPositionalArgument(ptr.Pointer(), C.CString(name), C.CString(description), C.CString(syntax))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) AddVersionOption() *QCommandLineOption {
|
|
defer qt.Recovering("QCommandLineParser::addVersionOption")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQCommandLineOptionFromPointer(C.QCommandLineParser_AddVersionOption(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) ApplicationDescription() string {
|
|
defer qt.Recovering("QCommandLineParser::applicationDescription")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QCommandLineParser_ApplicationDescription(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) ClearPositionalArguments() {
|
|
defer qt.Recovering("QCommandLineParser::clearPositionalArguments")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineParser_ClearPositionalArguments(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) ErrorText() string {
|
|
defer qt.Recovering("QCommandLineParser::errorText")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QCommandLineParser_ErrorText(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) HelpText() string {
|
|
defer qt.Recovering("QCommandLineParser::helpText")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QCommandLineParser_HelpText(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) IsSet2(option QCommandLineOption_ITF) bool {
|
|
defer qt.Recovering("QCommandLineParser::isSet")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QCommandLineParser_IsSet2(ptr.Pointer(), PointerFromQCommandLineOption(option)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) IsSet(name string) bool {
|
|
defer qt.Recovering("QCommandLineParser::isSet")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QCommandLineParser_IsSet(ptr.Pointer(), C.CString(name)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) OptionNames() []string {
|
|
defer qt.Recovering("QCommandLineParser::optionNames")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QCommandLineParser_OptionNames(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) Parse(arguments []string) bool {
|
|
defer qt.Recovering("QCommandLineParser::parse")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QCommandLineParser_Parse(ptr.Pointer(), C.CString(strings.Join(arguments, "|"))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) PositionalArguments() []string {
|
|
defer qt.Recovering("QCommandLineParser::positionalArguments")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QCommandLineParser_PositionalArguments(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) Process2(app QCoreApplication_ITF) {
|
|
defer qt.Recovering("QCommandLineParser::process")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineParser_Process2(ptr.Pointer(), PointerFromQCoreApplication(app))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) Process(arguments []string) {
|
|
defer qt.Recovering("QCommandLineParser::process")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineParser_Process(ptr.Pointer(), C.CString(strings.Join(arguments, "|")))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) SetApplicationDescription(description string) {
|
|
defer qt.Recovering("QCommandLineParser::setApplicationDescription")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineParser_SetApplicationDescription(ptr.Pointer(), C.CString(description))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) SetOptionsAfterPositionalArgumentsMode(parsingMode QCommandLineParser__OptionsAfterPositionalArgumentsMode) {
|
|
defer qt.Recovering("QCommandLineParser::setOptionsAfterPositionalArgumentsMode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineParser_SetOptionsAfterPositionalArgumentsMode(ptr.Pointer(), C.int(parsingMode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) SetSingleDashWordOptionMode(singleDashWordOptionMode QCommandLineParser__SingleDashWordOptionMode) {
|
|
defer qt.Recovering("QCommandLineParser::setSingleDashWordOptionMode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineParser_SetSingleDashWordOptionMode(ptr.Pointer(), C.int(singleDashWordOptionMode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) ShowHelp(exitCode int) {
|
|
defer qt.Recovering("QCommandLineParser::showHelp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineParser_ShowHelp(ptr.Pointer(), C.int(exitCode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) ShowVersion() {
|
|
defer qt.Recovering("QCommandLineParser::showVersion")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineParser_ShowVersion(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) UnknownOptionNames() []string {
|
|
defer qt.Recovering("QCommandLineParser::unknownOptionNames")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QCommandLineParser_UnknownOptionNames(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) Value2(option QCommandLineOption_ITF) string {
|
|
defer qt.Recovering("QCommandLineParser::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QCommandLineParser_Value2(ptr.Pointer(), PointerFromQCommandLineOption(option)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) Value(optionName string) string {
|
|
defer qt.Recovering("QCommandLineParser::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QCommandLineParser_Value(ptr.Pointer(), C.CString(optionName)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) Values2(option QCommandLineOption_ITF) []string {
|
|
defer qt.Recovering("QCommandLineParser::values")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QCommandLineParser_Values2(ptr.Pointer(), PointerFromQCommandLineOption(option))), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) Values(optionName string) []string {
|
|
defer qt.Recovering("QCommandLineParser::values")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QCommandLineParser_Values(ptr.Pointer(), C.CString(optionName))), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QCommandLineParser) DestroyQCommandLineParser() {
|
|
defer qt.Recovering("QCommandLineParser::~QCommandLineParser")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCommandLineParser_DestroyQCommandLineParser(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QContiguousCache struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QContiguousCache_ITF interface {
|
|
QContiguousCache_PTR() *QContiguousCache
|
|
}
|
|
|
|
func (p *QContiguousCache) QContiguousCache_PTR() *QContiguousCache {
|
|
return p
|
|
}
|
|
|
|
func (p *QContiguousCache) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QContiguousCache) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQContiguousCache(ptr QContiguousCache_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QContiguousCache_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQContiguousCacheFromPointer(ptr unsafe.Pointer) *QContiguousCache {
|
|
var n = new(QContiguousCache)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQContiguousCacheFromPointer(ptr unsafe.Pointer) *QContiguousCache {
|
|
var n = NewQContiguousCacheFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QCoreApplication struct {
|
|
QObject
|
|
}
|
|
|
|
type QCoreApplication_ITF interface {
|
|
QObject_ITF
|
|
QCoreApplication_PTR() *QCoreApplication
|
|
}
|
|
|
|
func (p *QCoreApplication) QCoreApplication_PTR() *QCoreApplication {
|
|
return p
|
|
}
|
|
|
|
func (p *QCoreApplication) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QCoreApplication) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCoreApplication(ptr QCoreApplication_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCoreApplication_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCoreApplicationFromPointer(ptr unsafe.Pointer) *QCoreApplication {
|
|
var n = new(QCoreApplication)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQCoreApplicationFromPointer(ptr unsafe.Pointer) *QCoreApplication {
|
|
var n = NewQCoreApplicationFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QCoreApplication_") {
|
|
n.SetObjectName("QCoreApplication_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func QCoreApplication_ApplicationName() string {
|
|
defer qt.Recovering("QCoreApplication::applicationName")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_ApplicationName())
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ApplicationName() string {
|
|
defer qt.Recovering("QCoreApplication::applicationName")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_ApplicationName())
|
|
}
|
|
|
|
func QCoreApplication_ApplicationVersion() string {
|
|
defer qt.Recovering("QCoreApplication::applicationVersion")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_ApplicationVersion())
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ApplicationVersion() string {
|
|
defer qt.Recovering("QCoreApplication::applicationVersion")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_ApplicationVersion())
|
|
}
|
|
|
|
func QCoreApplication_IsQuitLockEnabled() bool {
|
|
defer qt.Recovering("QCoreApplication::isQuitLockEnabled")
|
|
|
|
return C.QCoreApplication_QCoreApplication_IsQuitLockEnabled() != 0
|
|
}
|
|
|
|
func (ptr *QCoreApplication) IsQuitLockEnabled() bool {
|
|
defer qt.Recovering("QCoreApplication::isQuitLockEnabled")
|
|
|
|
return C.QCoreApplication_QCoreApplication_IsQuitLockEnabled() != 0
|
|
}
|
|
|
|
func QCoreApplication_OrganizationDomain() string {
|
|
defer qt.Recovering("QCoreApplication::organizationDomain")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_OrganizationDomain())
|
|
}
|
|
|
|
func (ptr *QCoreApplication) OrganizationDomain() string {
|
|
defer qt.Recovering("QCoreApplication::organizationDomain")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_OrganizationDomain())
|
|
}
|
|
|
|
func QCoreApplication_OrganizationName() string {
|
|
defer qt.Recovering("QCoreApplication::organizationName")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_OrganizationName())
|
|
}
|
|
|
|
func (ptr *QCoreApplication) OrganizationName() string {
|
|
defer qt.Recovering("QCoreApplication::organizationName")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_OrganizationName())
|
|
}
|
|
|
|
func QCoreApplication_SetApplicationName(application string) {
|
|
defer qt.Recovering("QCoreApplication::setApplicationName")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetApplicationName(C.CString(application))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) SetApplicationName(application string) {
|
|
defer qt.Recovering("QCoreApplication::setApplicationName")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetApplicationName(C.CString(application))
|
|
}
|
|
|
|
func QCoreApplication_SetApplicationVersion(version string) {
|
|
defer qt.Recovering("QCoreApplication::setApplicationVersion")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetApplicationVersion(C.CString(version))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) SetApplicationVersion(version string) {
|
|
defer qt.Recovering("QCoreApplication::setApplicationVersion")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetApplicationVersion(C.CString(version))
|
|
}
|
|
|
|
func QCoreApplication_SetOrganizationDomain(orgDomain string) {
|
|
defer qt.Recovering("QCoreApplication::setOrganizationDomain")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetOrganizationDomain(C.CString(orgDomain))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) SetOrganizationDomain(orgDomain string) {
|
|
defer qt.Recovering("QCoreApplication::setOrganizationDomain")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetOrganizationDomain(C.CString(orgDomain))
|
|
}
|
|
|
|
func QCoreApplication_SetOrganizationName(orgName string) {
|
|
defer qt.Recovering("QCoreApplication::setOrganizationName")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetOrganizationName(C.CString(orgName))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) SetOrganizationName(orgName string) {
|
|
defer qt.Recovering("QCoreApplication::setOrganizationName")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetOrganizationName(C.CString(orgName))
|
|
}
|
|
|
|
func QCoreApplication_SetQuitLockEnabled(enabled bool) {
|
|
defer qt.Recovering("QCoreApplication::setQuitLockEnabled")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetQuitLockEnabled(C.int(qt.GoBoolToInt(enabled)))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) SetQuitLockEnabled(enabled bool) {
|
|
defer qt.Recovering("QCoreApplication::setQuitLockEnabled")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetQuitLockEnabled(C.int(qt.GoBoolToInt(enabled)))
|
|
}
|
|
|
|
func NewQCoreApplication(argc int, argv []string) *QCoreApplication {
|
|
defer qt.Recovering("QCoreApplication::QCoreApplication")
|
|
|
|
return newQCoreApplicationFromPointer(C.QCoreApplication_NewQCoreApplication(C.int(argc), C.CString(strings.Join(argv, "|"))))
|
|
}
|
|
|
|
//export callbackQCoreApplication_AboutToQuit
|
|
func callbackQCoreApplication_AboutToQuit(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QCoreApplication::aboutToQuit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "aboutToQuit"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectAboutToQuit(f func()) {
|
|
defer qt.Recovering("connect QCoreApplication::aboutToQuit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_ConnectAboutToQuit(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "aboutToQuit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectAboutToQuit() {
|
|
defer qt.Recovering("disconnect QCoreApplication::aboutToQuit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_DisconnectAboutToQuit(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "aboutToQuit")
|
|
}
|
|
}
|
|
|
|
func QCoreApplication_AddLibraryPath(path string) {
|
|
defer qt.Recovering("QCoreApplication::addLibraryPath")
|
|
|
|
C.QCoreApplication_QCoreApplication_AddLibraryPath(C.CString(path))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) AddLibraryPath(path string) {
|
|
defer qt.Recovering("QCoreApplication::addLibraryPath")
|
|
|
|
C.QCoreApplication_QCoreApplication_AddLibraryPath(C.CString(path))
|
|
}
|
|
|
|
func QCoreApplication_ApplicationDirPath() string {
|
|
defer qt.Recovering("QCoreApplication::applicationDirPath")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_ApplicationDirPath())
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ApplicationDirPath() string {
|
|
defer qt.Recovering("QCoreApplication::applicationDirPath")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_ApplicationDirPath())
|
|
}
|
|
|
|
func QCoreApplication_ApplicationFilePath() string {
|
|
defer qt.Recovering("QCoreApplication::applicationFilePath")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_ApplicationFilePath())
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ApplicationFilePath() string {
|
|
defer qt.Recovering("QCoreApplication::applicationFilePath")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_ApplicationFilePath())
|
|
}
|
|
|
|
func QCoreApplication_ApplicationPid() int64 {
|
|
defer qt.Recovering("QCoreApplication::applicationPid")
|
|
|
|
return int64(C.QCoreApplication_QCoreApplication_ApplicationPid())
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ApplicationPid() int64 {
|
|
defer qt.Recovering("QCoreApplication::applicationPid")
|
|
|
|
return int64(C.QCoreApplication_QCoreApplication_ApplicationPid())
|
|
}
|
|
|
|
func QCoreApplication_Arguments() []string {
|
|
defer qt.Recovering("QCoreApplication::arguments")
|
|
|
|
return strings.Split(C.GoString(C.QCoreApplication_QCoreApplication_Arguments()), "|")
|
|
}
|
|
|
|
func (ptr *QCoreApplication) Arguments() []string {
|
|
defer qt.Recovering("QCoreApplication::arguments")
|
|
|
|
return strings.Split(C.GoString(C.QCoreApplication_QCoreApplication_Arguments()), "|")
|
|
}
|
|
|
|
func QCoreApplication_ClosingDown() bool {
|
|
defer qt.Recovering("QCoreApplication::closingDown")
|
|
|
|
return C.QCoreApplication_QCoreApplication_ClosingDown() != 0
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ClosingDown() bool {
|
|
defer qt.Recovering("QCoreApplication::closingDown")
|
|
|
|
return C.QCoreApplication_QCoreApplication_ClosingDown() != 0
|
|
}
|
|
|
|
//export callbackQCoreApplication_Event
|
|
func callbackQCoreApplication_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QCoreApplication::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQCoreApplicationFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QCoreApplication::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QCoreApplication::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QCoreApplication::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QCoreApplication_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCoreApplication) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QCoreApplication::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QCoreApplication_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QCoreApplication_EventDispatcher() *QAbstractEventDispatcher {
|
|
defer qt.Recovering("QCoreApplication::eventDispatcher")
|
|
|
|
return NewQAbstractEventDispatcherFromPointer(C.QCoreApplication_QCoreApplication_EventDispatcher())
|
|
}
|
|
|
|
func (ptr *QCoreApplication) EventDispatcher() *QAbstractEventDispatcher {
|
|
defer qt.Recovering("QCoreApplication::eventDispatcher")
|
|
|
|
return NewQAbstractEventDispatcherFromPointer(C.QCoreApplication_QCoreApplication_EventDispatcher())
|
|
}
|
|
|
|
func QCoreApplication_Exec() int {
|
|
defer qt.Recovering("QCoreApplication::exec")
|
|
|
|
return int(C.QCoreApplication_QCoreApplication_Exec())
|
|
}
|
|
|
|
func (ptr *QCoreApplication) Exec() int {
|
|
defer qt.Recovering("QCoreApplication::exec")
|
|
|
|
return int(C.QCoreApplication_QCoreApplication_Exec())
|
|
}
|
|
|
|
func QCoreApplication_Exit(returnCode int) {
|
|
defer qt.Recovering("QCoreApplication::exit")
|
|
|
|
C.QCoreApplication_QCoreApplication_Exit(C.int(returnCode))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) Exit(returnCode int) {
|
|
defer qt.Recovering("QCoreApplication::exit")
|
|
|
|
C.QCoreApplication_QCoreApplication_Exit(C.int(returnCode))
|
|
}
|
|
|
|
func QCoreApplication_Flush() {
|
|
defer qt.Recovering("QCoreApplication::flush")
|
|
|
|
C.QCoreApplication_QCoreApplication_Flush()
|
|
}
|
|
|
|
func (ptr *QCoreApplication) Flush() {
|
|
defer qt.Recovering("QCoreApplication::flush")
|
|
|
|
C.QCoreApplication_QCoreApplication_Flush()
|
|
}
|
|
|
|
func (ptr *QCoreApplication) InstallNativeEventFilter(filterObj QAbstractNativeEventFilter_ITF) {
|
|
defer qt.Recovering("QCoreApplication::installNativeEventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_InstallNativeEventFilter(ptr.Pointer(), PointerFromQAbstractNativeEventFilter(filterObj))
|
|
}
|
|
}
|
|
|
|
func QCoreApplication_InstallTranslator(translationFile QTranslator_ITF) bool {
|
|
defer qt.Recovering("QCoreApplication::installTranslator")
|
|
|
|
return C.QCoreApplication_QCoreApplication_InstallTranslator(PointerFromQTranslator(translationFile)) != 0
|
|
}
|
|
|
|
func (ptr *QCoreApplication) InstallTranslator(translationFile QTranslator_ITF) bool {
|
|
defer qt.Recovering("QCoreApplication::installTranslator")
|
|
|
|
return C.QCoreApplication_QCoreApplication_InstallTranslator(PointerFromQTranslator(translationFile)) != 0
|
|
}
|
|
|
|
func QCoreApplication_Instance() *QCoreApplication {
|
|
defer qt.Recovering("QCoreApplication::instance")
|
|
|
|
return NewQCoreApplicationFromPointer(C.QCoreApplication_QCoreApplication_Instance())
|
|
}
|
|
|
|
func (ptr *QCoreApplication) Instance() *QCoreApplication {
|
|
defer qt.Recovering("QCoreApplication::instance")
|
|
|
|
return NewQCoreApplicationFromPointer(C.QCoreApplication_QCoreApplication_Instance())
|
|
}
|
|
|
|
func QCoreApplication_IsSetuidAllowed() bool {
|
|
defer qt.Recovering("QCoreApplication::isSetuidAllowed")
|
|
|
|
return C.QCoreApplication_QCoreApplication_IsSetuidAllowed() != 0
|
|
}
|
|
|
|
func (ptr *QCoreApplication) IsSetuidAllowed() bool {
|
|
defer qt.Recovering("QCoreApplication::isSetuidAllowed")
|
|
|
|
return C.QCoreApplication_QCoreApplication_IsSetuidAllowed() != 0
|
|
}
|
|
|
|
func QCoreApplication_LibraryPaths() []string {
|
|
defer qt.Recovering("QCoreApplication::libraryPaths")
|
|
|
|
return strings.Split(C.GoString(C.QCoreApplication_QCoreApplication_LibraryPaths()), "|")
|
|
}
|
|
|
|
func (ptr *QCoreApplication) LibraryPaths() []string {
|
|
defer qt.Recovering("QCoreApplication::libraryPaths")
|
|
|
|
return strings.Split(C.GoString(C.QCoreApplication_QCoreApplication_LibraryPaths()), "|")
|
|
}
|
|
|
|
func QCoreApplication_PostEvent(receiver QObject_ITF, event QEvent_ITF, priority int) {
|
|
defer qt.Recovering("QCoreApplication::postEvent")
|
|
|
|
C.QCoreApplication_QCoreApplication_PostEvent(PointerFromQObject(receiver), PointerFromQEvent(event), C.int(priority))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) PostEvent(receiver QObject_ITF, event QEvent_ITF, priority int) {
|
|
defer qt.Recovering("QCoreApplication::postEvent")
|
|
|
|
C.QCoreApplication_QCoreApplication_PostEvent(PointerFromQObject(receiver), PointerFromQEvent(event), C.int(priority))
|
|
}
|
|
|
|
func QCoreApplication_ProcessEvents(flags QEventLoop__ProcessEventsFlag) {
|
|
defer qt.Recovering("QCoreApplication::processEvents")
|
|
|
|
C.QCoreApplication_QCoreApplication_ProcessEvents(C.int(flags))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ProcessEvents(flags QEventLoop__ProcessEventsFlag) {
|
|
defer qt.Recovering("QCoreApplication::processEvents")
|
|
|
|
C.QCoreApplication_QCoreApplication_ProcessEvents(C.int(flags))
|
|
}
|
|
|
|
func QCoreApplication_ProcessEvents2(flags QEventLoop__ProcessEventsFlag, maxtime int) {
|
|
defer qt.Recovering("QCoreApplication::processEvents")
|
|
|
|
C.QCoreApplication_QCoreApplication_ProcessEvents2(C.int(flags), C.int(maxtime))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ProcessEvents2(flags QEventLoop__ProcessEventsFlag, maxtime int) {
|
|
defer qt.Recovering("QCoreApplication::processEvents")
|
|
|
|
C.QCoreApplication_QCoreApplication_ProcessEvents2(C.int(flags), C.int(maxtime))
|
|
}
|
|
|
|
//export callbackQCoreApplication_Quit
|
|
func callbackQCoreApplication_Quit(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QCoreApplication::quit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "quit"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectQuit(f func()) {
|
|
defer qt.Recovering("connect QCoreApplication::quit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "quit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectQuit() {
|
|
defer qt.Recovering("disconnect QCoreApplication::quit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "quit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) Quit() {
|
|
defer qt.Recovering("QCoreApplication::quit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_Quit(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func QCoreApplication_RemoveLibraryPath(path string) {
|
|
defer qt.Recovering("QCoreApplication::removeLibraryPath")
|
|
|
|
C.QCoreApplication_QCoreApplication_RemoveLibraryPath(C.CString(path))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) RemoveLibraryPath(path string) {
|
|
defer qt.Recovering("QCoreApplication::removeLibraryPath")
|
|
|
|
C.QCoreApplication_QCoreApplication_RemoveLibraryPath(C.CString(path))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) RemoveNativeEventFilter(filterObject QAbstractNativeEventFilter_ITF) {
|
|
defer qt.Recovering("QCoreApplication::removeNativeEventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_RemoveNativeEventFilter(ptr.Pointer(), PointerFromQAbstractNativeEventFilter(filterObject))
|
|
}
|
|
}
|
|
|
|
func QCoreApplication_RemovePostedEvents(receiver QObject_ITF, eventType int) {
|
|
defer qt.Recovering("QCoreApplication::removePostedEvents")
|
|
|
|
C.QCoreApplication_QCoreApplication_RemovePostedEvents(PointerFromQObject(receiver), C.int(eventType))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) RemovePostedEvents(receiver QObject_ITF, eventType int) {
|
|
defer qt.Recovering("QCoreApplication::removePostedEvents")
|
|
|
|
C.QCoreApplication_QCoreApplication_RemovePostedEvents(PointerFromQObject(receiver), C.int(eventType))
|
|
}
|
|
|
|
func QCoreApplication_RemoveTranslator(translationFile QTranslator_ITF) bool {
|
|
defer qt.Recovering("QCoreApplication::removeTranslator")
|
|
|
|
return C.QCoreApplication_QCoreApplication_RemoveTranslator(PointerFromQTranslator(translationFile)) != 0
|
|
}
|
|
|
|
func (ptr *QCoreApplication) RemoveTranslator(translationFile QTranslator_ITF) bool {
|
|
defer qt.Recovering("QCoreApplication::removeTranslator")
|
|
|
|
return C.QCoreApplication_QCoreApplication_RemoveTranslator(PointerFromQTranslator(translationFile)) != 0
|
|
}
|
|
|
|
func QCoreApplication_SendEvent(receiver QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QCoreApplication::sendEvent")
|
|
|
|
return C.QCoreApplication_QCoreApplication_SendEvent(PointerFromQObject(receiver), PointerFromQEvent(event)) != 0
|
|
}
|
|
|
|
func (ptr *QCoreApplication) SendEvent(receiver QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QCoreApplication::sendEvent")
|
|
|
|
return C.QCoreApplication_QCoreApplication_SendEvent(PointerFromQObject(receiver), PointerFromQEvent(event)) != 0
|
|
}
|
|
|
|
func QCoreApplication_SendPostedEvents(receiver QObject_ITF, event_type int) {
|
|
defer qt.Recovering("QCoreApplication::sendPostedEvents")
|
|
|
|
C.QCoreApplication_QCoreApplication_SendPostedEvents(PointerFromQObject(receiver), C.int(event_type))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) SendPostedEvents(receiver QObject_ITF, event_type int) {
|
|
defer qt.Recovering("QCoreApplication::sendPostedEvents")
|
|
|
|
C.QCoreApplication_QCoreApplication_SendPostedEvents(PointerFromQObject(receiver), C.int(event_type))
|
|
}
|
|
|
|
func QCoreApplication_SetAttribute(attribute Qt__ApplicationAttribute, on bool) {
|
|
defer qt.Recovering("QCoreApplication::setAttribute")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetAttribute(C.int(attribute), C.int(qt.GoBoolToInt(on)))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) SetAttribute(attribute Qt__ApplicationAttribute, on bool) {
|
|
defer qt.Recovering("QCoreApplication::setAttribute")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetAttribute(C.int(attribute), C.int(qt.GoBoolToInt(on)))
|
|
}
|
|
|
|
func QCoreApplication_SetEventDispatcher(eventDispatcher QAbstractEventDispatcher_ITF) {
|
|
defer qt.Recovering("QCoreApplication::setEventDispatcher")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetEventDispatcher(PointerFromQAbstractEventDispatcher(eventDispatcher))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) SetEventDispatcher(eventDispatcher QAbstractEventDispatcher_ITF) {
|
|
defer qt.Recovering("QCoreApplication::setEventDispatcher")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetEventDispatcher(PointerFromQAbstractEventDispatcher(eventDispatcher))
|
|
}
|
|
|
|
func QCoreApplication_SetLibraryPaths(paths []string) {
|
|
defer qt.Recovering("QCoreApplication::setLibraryPaths")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetLibraryPaths(C.CString(strings.Join(paths, "|")))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) SetLibraryPaths(paths []string) {
|
|
defer qt.Recovering("QCoreApplication::setLibraryPaths")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetLibraryPaths(C.CString(strings.Join(paths, "|")))
|
|
}
|
|
|
|
func QCoreApplication_SetSetuidAllowed(allow bool) {
|
|
defer qt.Recovering("QCoreApplication::setSetuidAllowed")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetSetuidAllowed(C.int(qt.GoBoolToInt(allow)))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) SetSetuidAllowed(allow bool) {
|
|
defer qt.Recovering("QCoreApplication::setSetuidAllowed")
|
|
|
|
C.QCoreApplication_QCoreApplication_SetSetuidAllowed(C.int(qt.GoBoolToInt(allow)))
|
|
}
|
|
|
|
func QCoreApplication_StartingUp() bool {
|
|
defer qt.Recovering("QCoreApplication::startingUp")
|
|
|
|
return C.QCoreApplication_QCoreApplication_StartingUp() != 0
|
|
}
|
|
|
|
func (ptr *QCoreApplication) StartingUp() bool {
|
|
defer qt.Recovering("QCoreApplication::startingUp")
|
|
|
|
return C.QCoreApplication_QCoreApplication_StartingUp() != 0
|
|
}
|
|
|
|
func QCoreApplication_TestAttribute(attribute Qt__ApplicationAttribute) bool {
|
|
defer qt.Recovering("QCoreApplication::testAttribute")
|
|
|
|
return C.QCoreApplication_QCoreApplication_TestAttribute(C.int(attribute)) != 0
|
|
}
|
|
|
|
func (ptr *QCoreApplication) TestAttribute(attribute Qt__ApplicationAttribute) bool {
|
|
defer qt.Recovering("QCoreApplication::testAttribute")
|
|
|
|
return C.QCoreApplication_QCoreApplication_TestAttribute(C.int(attribute)) != 0
|
|
}
|
|
|
|
func QCoreApplication_Translate(context string, sourceText string, disambiguation string, n int) string {
|
|
defer qt.Recovering("QCoreApplication::translate")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_Translate(C.CString(context), C.CString(sourceText), C.CString(disambiguation), C.int(n)))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) Translate(context string, sourceText string, disambiguation string, n int) string {
|
|
defer qt.Recovering("QCoreApplication::translate")
|
|
|
|
return C.GoString(C.QCoreApplication_QCoreApplication_Translate(C.CString(context), C.CString(sourceText), C.CString(disambiguation), C.int(n)))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DestroyQCoreApplication() {
|
|
defer qt.Recovering("QCoreApplication::~QCoreApplication")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QCoreApplication_DestroyQCoreApplication(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func QCoreApplication_ApplicationFlags() int {
|
|
defer qt.Recovering("QCoreApplication::ApplicationFlags")
|
|
|
|
return int(C.QCoreApplication_QCoreApplication_ApplicationFlags())
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ApplicationFlags() int {
|
|
defer qt.Recovering("QCoreApplication::ApplicationFlags")
|
|
|
|
return int(C.QCoreApplication_QCoreApplication_ApplicationFlags())
|
|
}
|
|
|
|
//export callbackQCoreApplication_TimerEvent
|
|
func callbackQCoreApplication_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QCoreApplication::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQCoreApplicationFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QCoreApplication::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QCoreApplication::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QCoreApplication::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QCoreApplication::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCoreApplication_ChildEvent
|
|
func callbackQCoreApplication_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QCoreApplication::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQCoreApplicationFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QCoreApplication::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QCoreApplication::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QCoreApplication::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QCoreApplication::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCoreApplication_ConnectNotify
|
|
func callbackQCoreApplication_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QCoreApplication::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQCoreApplicationFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QCoreApplication::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QCoreApplication::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QCoreApplication::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QCoreApplication::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQCoreApplication_CustomEvent
|
|
func callbackQCoreApplication_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QCoreApplication::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQCoreApplicationFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QCoreApplication::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QCoreApplication::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QCoreApplication::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QCoreApplication::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCoreApplication_DeleteLater
|
|
func callbackQCoreApplication_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QCoreApplication::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCoreApplicationFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QCoreApplication::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QCoreApplication::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DeleteLater() {
|
|
defer qt.Recovering("QCoreApplication::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QCoreApplication_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DeleteLaterDefault() {
|
|
defer qt.Recovering("QCoreApplication::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QCoreApplication_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCoreApplication_DisconnectNotify
|
|
func callbackQCoreApplication_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QCoreApplication::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQCoreApplicationFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QCoreApplication::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QCoreApplication::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QCoreApplication::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QCoreApplication::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCoreApplication_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQCoreApplication_EventFilter
|
|
func callbackQCoreApplication_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QCoreApplication::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQCoreApplicationFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QCoreApplication::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QCoreApplication::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QCoreApplication::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QCoreApplication_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCoreApplication) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QCoreApplication::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QCoreApplication_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCoreApplication_MetaObject
|
|
func callbackQCoreApplication_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QCoreApplication::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQCoreApplicationFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QCoreApplication) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QCoreApplication::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QCoreApplication::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCoreApplication) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QCoreApplication::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QCoreApplication_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCoreApplication) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QCoreApplication::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QCoreApplication_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//QCryptographicHash::Algorithm
|
|
type QCryptographicHash__Algorithm int64
|
|
|
|
const (
|
|
QCryptographicHash__Md4 = QCryptographicHash__Algorithm(0)
|
|
QCryptographicHash__Md5 = QCryptographicHash__Algorithm(1)
|
|
QCryptographicHash__Sha1 = QCryptographicHash__Algorithm(2)
|
|
QCryptographicHash__Sha224 = QCryptographicHash__Algorithm(3)
|
|
QCryptographicHash__Sha256 = QCryptographicHash__Algorithm(4)
|
|
QCryptographicHash__Sha384 = QCryptographicHash__Algorithm(5)
|
|
QCryptographicHash__Sha512 = QCryptographicHash__Algorithm(6)
|
|
QCryptographicHash__Sha3_224 = QCryptographicHash__Algorithm(7)
|
|
QCryptographicHash__Sha3_256 = QCryptographicHash__Algorithm(8)
|
|
QCryptographicHash__Sha3_384 = QCryptographicHash__Algorithm(9)
|
|
QCryptographicHash__Sha3_512 = QCryptographicHash__Algorithm(10)
|
|
)
|
|
|
|
type QCryptographicHash struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QCryptographicHash_ITF interface {
|
|
QCryptographicHash_PTR() *QCryptographicHash
|
|
}
|
|
|
|
func (p *QCryptographicHash) QCryptographicHash_PTR() *QCryptographicHash {
|
|
return p
|
|
}
|
|
|
|
func (p *QCryptographicHash) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QCryptographicHash) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQCryptographicHash(ptr QCryptographicHash_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCryptographicHash_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCryptographicHashFromPointer(ptr unsafe.Pointer) *QCryptographicHash {
|
|
var n = new(QCryptographicHash)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQCryptographicHashFromPointer(ptr unsafe.Pointer) *QCryptographicHash {
|
|
var n = NewQCryptographicHashFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQCryptographicHash(method QCryptographicHash__Algorithm) *QCryptographicHash {
|
|
defer qt.Recovering("QCryptographicHash::QCryptographicHash")
|
|
|
|
return newQCryptographicHashFromPointer(C.QCryptographicHash_NewQCryptographicHash(C.int(method)))
|
|
}
|
|
|
|
func (ptr *QCryptographicHash) AddData3(device QIODevice_ITF) bool {
|
|
defer qt.Recovering("QCryptographicHash::addData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QCryptographicHash_AddData3(ptr.Pointer(), PointerFromQIODevice(device)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCryptographicHash) AddData2(data string) {
|
|
defer qt.Recovering("QCryptographicHash::addData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCryptographicHash_AddData2(ptr.Pointer(), C.CString(data))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCryptographicHash) AddData(data string, length int) {
|
|
defer qt.Recovering("QCryptographicHash::addData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCryptographicHash_AddData(ptr.Pointer(), C.CString(data), C.int(length))
|
|
}
|
|
}
|
|
|
|
func QCryptographicHash_Hash(data string, method QCryptographicHash__Algorithm) string {
|
|
defer qt.Recovering("QCryptographicHash::hash")
|
|
|
|
return C.GoString(C.QCryptographicHash_QCryptographicHash_Hash(C.CString(data), C.int(method)))
|
|
}
|
|
|
|
func (ptr *QCryptographicHash) Hash(data string, method QCryptographicHash__Algorithm) string {
|
|
defer qt.Recovering("QCryptographicHash::hash")
|
|
|
|
return C.GoString(C.QCryptographicHash_QCryptographicHash_Hash(C.CString(data), C.int(method)))
|
|
}
|
|
|
|
func (ptr *QCryptographicHash) Reset() {
|
|
defer qt.Recovering("QCryptographicHash::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCryptographicHash_Reset(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCryptographicHash) Result() string {
|
|
defer qt.Recovering("QCryptographicHash::result")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QCryptographicHash_Result(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCryptographicHash) DestroyQCryptographicHash() {
|
|
defer qt.Recovering("QCryptographicHash::~QCryptographicHash")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QCryptographicHash_DestroyQCryptographicHash(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QDataStream::ByteOrder
|
|
type QDataStream__ByteOrder int64
|
|
|
|
const (
|
|
QDataStream__BigEndian = QDataStream__ByteOrder(QSysInfo__BigEndian)
|
|
QDataStream__LittleEndian = QDataStream__ByteOrder(QSysInfo__LittleEndian)
|
|
)
|
|
|
|
//QDataStream::FloatingPointPrecision
|
|
type QDataStream__FloatingPointPrecision int64
|
|
|
|
const (
|
|
QDataStream__SinglePrecision = QDataStream__FloatingPointPrecision(0)
|
|
QDataStream__DoublePrecision = QDataStream__FloatingPointPrecision(1)
|
|
)
|
|
|
|
//QDataStream::Status
|
|
type QDataStream__Status int64
|
|
|
|
const (
|
|
QDataStream__Ok = QDataStream__Status(0)
|
|
QDataStream__ReadPastEnd = QDataStream__Status(1)
|
|
QDataStream__ReadCorruptData = QDataStream__Status(2)
|
|
QDataStream__WriteFailed = QDataStream__Status(3)
|
|
)
|
|
|
|
//QDataStream::Version
|
|
type QDataStream__Version int64
|
|
|
|
const (
|
|
QDataStream__Qt_1_0 = QDataStream__Version(1)
|
|
QDataStream__Qt_2_0 = QDataStream__Version(2)
|
|
QDataStream__Qt_2_1 = QDataStream__Version(3)
|
|
QDataStream__Qt_3_0 = QDataStream__Version(4)
|
|
QDataStream__Qt_3_1 = QDataStream__Version(5)
|
|
QDataStream__Qt_3_3 = QDataStream__Version(6)
|
|
QDataStream__Qt_4_0 = QDataStream__Version(7)
|
|
QDataStream__Qt_4_1 = QDataStream__Version(QDataStream__Qt_4_0)
|
|
QDataStream__Qt_4_2 = QDataStream__Version(8)
|
|
QDataStream__Qt_4_3 = QDataStream__Version(9)
|
|
QDataStream__Qt_4_4 = QDataStream__Version(10)
|
|
QDataStream__Qt_4_5 = QDataStream__Version(11)
|
|
QDataStream__Qt_4_6 = QDataStream__Version(12)
|
|
QDataStream__Qt_4_7 = QDataStream__Version(QDataStream__Qt_4_6)
|
|
QDataStream__Qt_4_8 = QDataStream__Version(QDataStream__Qt_4_7)
|
|
QDataStream__Qt_4_9 = QDataStream__Version(QDataStream__Qt_4_8)
|
|
QDataStream__Qt_5_0 = QDataStream__Version(13)
|
|
QDataStream__Qt_5_1 = QDataStream__Version(14)
|
|
QDataStream__Qt_5_2 = QDataStream__Version(15)
|
|
QDataStream__Qt_5_3 = QDataStream__Version(QDataStream__Qt_5_2)
|
|
QDataStream__Qt_5_4 = QDataStream__Version(16)
|
|
QDataStream__Qt_5_5 = QDataStream__Version(QDataStream__Qt_5_4)
|
|
QDataStream__Qt_5_6 = QDataStream__Version(17)
|
|
QDataStream__Qt_DefaultCompiledVersion = QDataStream__Version(QDataStream__Qt_5_6)
|
|
)
|
|
|
|
type QDataStream struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QDataStream_ITF interface {
|
|
QDataStream_PTR() *QDataStream
|
|
}
|
|
|
|
func (p *QDataStream) QDataStream_PTR() *QDataStream {
|
|
return p
|
|
}
|
|
|
|
func (p *QDataStream) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QDataStream) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQDataStream(ptr QDataStream_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QDataStream_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQDataStreamFromPointer(ptr unsafe.Pointer) *QDataStream {
|
|
var n = new(QDataStream)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQDataStreamFromPointer(ptr unsafe.Pointer) *QDataStream {
|
|
var n = NewQDataStreamFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQDataStream3(a string, mode QIODevice__OpenModeFlag) *QDataStream {
|
|
defer qt.Recovering("QDataStream::QDataStream")
|
|
|
|
return newQDataStreamFromPointer(C.QDataStream_NewQDataStream3(C.CString(a), C.int(mode)))
|
|
}
|
|
|
|
func (ptr *QDataStream) AtEnd() bool {
|
|
defer qt.Recovering("QDataStream::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDataStream_AtEnd(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func NewQDataStream() *QDataStream {
|
|
defer qt.Recovering("QDataStream::QDataStream")
|
|
|
|
return newQDataStreamFromPointer(C.QDataStream_NewQDataStream())
|
|
}
|
|
|
|
func NewQDataStream2(d QIODevice_ITF) *QDataStream {
|
|
defer qt.Recovering("QDataStream::QDataStream")
|
|
|
|
return newQDataStreamFromPointer(C.QDataStream_NewQDataStream2(PointerFromQIODevice(d)))
|
|
}
|
|
|
|
func NewQDataStream4(a string) *QDataStream {
|
|
defer qt.Recovering("QDataStream::QDataStream")
|
|
|
|
return newQDataStreamFromPointer(C.QDataStream_NewQDataStream4(C.CString(a)))
|
|
}
|
|
|
|
func (ptr *QDataStream) ByteOrder() QDataStream__ByteOrder {
|
|
defer qt.Recovering("QDataStream::byteOrder")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QDataStream__ByteOrder(C.QDataStream_ByteOrder(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDataStream) Device() *QIODevice {
|
|
defer qt.Recovering("QDataStream::device")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQIODeviceFromPointer(C.QDataStream_Device(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDataStream) FloatingPointPrecision() QDataStream__FloatingPointPrecision {
|
|
defer qt.Recovering("QDataStream::floatingPointPrecision")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QDataStream__FloatingPointPrecision(C.QDataStream_FloatingPointPrecision(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDataStream) ReadRawData(s string, len int) int {
|
|
defer qt.Recovering("QDataStream::readRawData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDataStream_ReadRawData(ptr.Pointer(), C.CString(s), C.int(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDataStream) ResetStatus() {
|
|
defer qt.Recovering("QDataStream::resetStatus")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDataStream_ResetStatus(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QDataStream) SetByteOrder(bo QDataStream__ByteOrder) {
|
|
defer qt.Recovering("QDataStream::setByteOrder")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDataStream_SetByteOrder(ptr.Pointer(), C.int(bo))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDataStream) SetDevice(d QIODevice_ITF) {
|
|
defer qt.Recovering("QDataStream::setDevice")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDataStream_SetDevice(ptr.Pointer(), PointerFromQIODevice(d))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDataStream) SetFloatingPointPrecision(precision QDataStream__FloatingPointPrecision) {
|
|
defer qt.Recovering("QDataStream::setFloatingPointPrecision")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDataStream_SetFloatingPointPrecision(ptr.Pointer(), C.int(precision))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDataStream) SetStatus(status QDataStream__Status) {
|
|
defer qt.Recovering("QDataStream::setStatus")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDataStream_SetStatus(ptr.Pointer(), C.int(status))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDataStream) SetVersion(v int) {
|
|
defer qt.Recovering("QDataStream::setVersion")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDataStream_SetVersion(ptr.Pointer(), C.int(v))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDataStream) SkipRawData(len int) int {
|
|
defer qt.Recovering("QDataStream::skipRawData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDataStream_SkipRawData(ptr.Pointer(), C.int(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDataStream) Status() QDataStream__Status {
|
|
defer qt.Recovering("QDataStream::status")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QDataStream__Status(C.QDataStream_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDataStream) Version() int {
|
|
defer qt.Recovering("QDataStream::version")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDataStream_Version(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDataStream) WriteRawData(s string, len int) int {
|
|
defer qt.Recovering("QDataStream::writeRawData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDataStream_WriteRawData(ptr.Pointer(), C.CString(s), C.int(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDataStream) DestroyQDataStream() {
|
|
defer qt.Recovering("QDataStream::~QDataStream")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDataStream_DestroyQDataStream(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QDate::MonthNameType
|
|
type QDate__MonthNameType int64
|
|
|
|
const (
|
|
QDate__DateFormat = QDate__MonthNameType(0)
|
|
QDate__StandaloneFormat = QDate__MonthNameType(1)
|
|
)
|
|
|
|
type QDate struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QDate_ITF interface {
|
|
QDate_PTR() *QDate
|
|
}
|
|
|
|
func (p *QDate) QDate_PTR() *QDate {
|
|
return p
|
|
}
|
|
|
|
func (p *QDate) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QDate) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQDate(ptr QDate_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QDate_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQDateFromPointer(ptr unsafe.Pointer) *QDate {
|
|
var n = new(QDate)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQDateFromPointer(ptr unsafe.Pointer) *QDate {
|
|
var n = NewQDateFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func QDate_IsLeapYear(year int) bool {
|
|
defer qt.Recovering("QDate::isLeapYear")
|
|
|
|
return C.QDate_QDate_IsLeapYear(C.int(year)) != 0
|
|
}
|
|
|
|
func (ptr *QDate) IsLeapYear(year int) bool {
|
|
defer qt.Recovering("QDate::isLeapYear")
|
|
|
|
return C.QDate_QDate_IsLeapYear(C.int(year)) != 0
|
|
}
|
|
|
|
func (ptr *QDate) ToString2(format Qt__DateFormat) string {
|
|
defer qt.Recovering("QDate::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDate_ToString2(ptr.Pointer(), C.int(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func NewQDate() *QDate {
|
|
defer qt.Recovering("QDate::QDate")
|
|
|
|
return newQDateFromPointer(C.QDate_NewQDate())
|
|
}
|
|
|
|
func NewQDate3(y int, m int, d int) *QDate {
|
|
defer qt.Recovering("QDate::QDate")
|
|
|
|
return newQDateFromPointer(C.QDate_NewQDate3(C.int(y), C.int(m), C.int(d)))
|
|
}
|
|
|
|
func (ptr *QDate) Day() int {
|
|
defer qt.Recovering("QDate::day")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDate_Day(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDate) DayOfWeek() int {
|
|
defer qt.Recovering("QDate::dayOfWeek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDate_DayOfWeek(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDate) DayOfYear() int {
|
|
defer qt.Recovering("QDate::dayOfYear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDate_DayOfYear(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDate) DaysInMonth() int {
|
|
defer qt.Recovering("QDate::daysInMonth")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDate_DaysInMonth(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDate) DaysInYear() int {
|
|
defer qt.Recovering("QDate::daysInYear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDate_DaysInYear(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDate) DaysTo(d QDate_ITF) int64 {
|
|
defer qt.Recovering("QDate::daysTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QDate_DaysTo(ptr.Pointer(), PointerFromQDate(d)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDate) GetDate(year int, month int, day int) {
|
|
defer qt.Recovering("QDate::getDate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDate_GetDate(ptr.Pointer(), C.int(year), C.int(month), C.int(day))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDate) IsNull() bool {
|
|
defer qt.Recovering("QDate::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDate_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QDate_IsValid2(year int, month int, day int) bool {
|
|
defer qt.Recovering("QDate::isValid")
|
|
|
|
return C.QDate_QDate_IsValid2(C.int(year), C.int(month), C.int(day)) != 0
|
|
}
|
|
|
|
func (ptr *QDate) IsValid2(year int, month int, day int) bool {
|
|
defer qt.Recovering("QDate::isValid")
|
|
|
|
return C.QDate_QDate_IsValid2(C.int(year), C.int(month), C.int(day)) != 0
|
|
}
|
|
|
|
func (ptr *QDate) IsValid() bool {
|
|
defer qt.Recovering("QDate::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDate_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QDate_LongDayName(weekday int, ty QDate__MonthNameType) string {
|
|
defer qt.Recovering("QDate::longDayName")
|
|
|
|
return C.GoString(C.QDate_QDate_LongDayName(C.int(weekday), C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QDate) LongDayName(weekday int, ty QDate__MonthNameType) string {
|
|
defer qt.Recovering("QDate::longDayName")
|
|
|
|
return C.GoString(C.QDate_QDate_LongDayName(C.int(weekday), C.int(ty)))
|
|
}
|
|
|
|
func QDate_LongMonthName(month int, ty QDate__MonthNameType) string {
|
|
defer qt.Recovering("QDate::longMonthName")
|
|
|
|
return C.GoString(C.QDate_QDate_LongMonthName(C.int(month), C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QDate) LongMonthName(month int, ty QDate__MonthNameType) string {
|
|
defer qt.Recovering("QDate::longMonthName")
|
|
|
|
return C.GoString(C.QDate_QDate_LongMonthName(C.int(month), C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QDate) Month() int {
|
|
defer qt.Recovering("QDate::month")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDate_Month(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDate) SetDate(year int, month int, day int) bool {
|
|
defer qt.Recovering("QDate::setDate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDate_SetDate(ptr.Pointer(), C.int(year), C.int(month), C.int(day)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QDate_ShortDayName(weekday int, ty QDate__MonthNameType) string {
|
|
defer qt.Recovering("QDate::shortDayName")
|
|
|
|
return C.GoString(C.QDate_QDate_ShortDayName(C.int(weekday), C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QDate) ShortDayName(weekday int, ty QDate__MonthNameType) string {
|
|
defer qt.Recovering("QDate::shortDayName")
|
|
|
|
return C.GoString(C.QDate_QDate_ShortDayName(C.int(weekday), C.int(ty)))
|
|
}
|
|
|
|
func QDate_ShortMonthName(month int, ty QDate__MonthNameType) string {
|
|
defer qt.Recovering("QDate::shortMonthName")
|
|
|
|
return C.GoString(C.QDate_QDate_ShortMonthName(C.int(month), C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QDate) ShortMonthName(month int, ty QDate__MonthNameType) string {
|
|
defer qt.Recovering("QDate::shortMonthName")
|
|
|
|
return C.GoString(C.QDate_QDate_ShortMonthName(C.int(month), C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QDate) ToJulianDay() int64 {
|
|
defer qt.Recovering("QDate::toJulianDay")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QDate_ToJulianDay(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDate) ToString(format string) string {
|
|
defer qt.Recovering("QDate::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDate_ToString(ptr.Pointer(), C.CString(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QDate) WeekNumber(yearNumber int) int {
|
|
defer qt.Recovering("QDate::weekNumber")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDate_WeekNumber(ptr.Pointer(), C.int(yearNumber)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDate) Year() int {
|
|
defer qt.Recovering("QDate::year")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDate_Year(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QDateTime struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QDateTime_ITF interface {
|
|
QDateTime_PTR() *QDateTime
|
|
}
|
|
|
|
func (p *QDateTime) QDateTime_PTR() *QDateTime {
|
|
return p
|
|
}
|
|
|
|
func (p *QDateTime) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QDateTime) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQDateTime(ptr QDateTime_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QDateTime_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQDateTimeFromPointer(ptr unsafe.Pointer) *QDateTime {
|
|
var n = new(QDateTime)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQDateTimeFromPointer(ptr unsafe.Pointer) *QDateTime {
|
|
var n = NewQDateTimeFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func QDateTime_CurrentDateTime() *QDateTime {
|
|
defer qt.Recovering("QDateTime::currentDateTime")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_CurrentDateTime())
|
|
}
|
|
|
|
func (ptr *QDateTime) CurrentDateTime() *QDateTime {
|
|
defer qt.Recovering("QDateTime::currentDateTime")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_CurrentDateTime())
|
|
}
|
|
|
|
func QDateTime_CurrentDateTimeUtc() *QDateTime {
|
|
defer qt.Recovering("QDateTime::currentDateTimeUtc")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_CurrentDateTimeUtc())
|
|
}
|
|
|
|
func (ptr *QDateTime) CurrentDateTimeUtc() *QDateTime {
|
|
defer qt.Recovering("QDateTime::currentDateTimeUtc")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_CurrentDateTimeUtc())
|
|
}
|
|
|
|
func QDateTime_CurrentMSecsSinceEpoch() int64 {
|
|
defer qt.Recovering("QDateTime::currentMSecsSinceEpoch")
|
|
|
|
return int64(C.QDateTime_QDateTime_CurrentMSecsSinceEpoch())
|
|
}
|
|
|
|
func (ptr *QDateTime) CurrentMSecsSinceEpoch() int64 {
|
|
defer qt.Recovering("QDateTime::currentMSecsSinceEpoch")
|
|
|
|
return int64(C.QDateTime_QDateTime_CurrentMSecsSinceEpoch())
|
|
}
|
|
|
|
func QDateTime_FromString(stri string, format Qt__DateFormat) *QDateTime {
|
|
defer qt.Recovering("QDateTime::fromString")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromString(C.CString(stri), C.int(format)))
|
|
}
|
|
|
|
func (ptr *QDateTime) FromString(stri string, format Qt__DateFormat) *QDateTime {
|
|
defer qt.Recovering("QDateTime::fromString")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromString(C.CString(stri), C.int(format)))
|
|
}
|
|
|
|
func QDateTime_FromString2(stri string, format string) *QDateTime {
|
|
defer qt.Recovering("QDateTime::fromString")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromString2(C.CString(stri), C.CString(format)))
|
|
}
|
|
|
|
func (ptr *QDateTime) FromString2(stri string, format string) *QDateTime {
|
|
defer qt.Recovering("QDateTime::fromString")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromString2(C.CString(stri), C.CString(format)))
|
|
}
|
|
|
|
func (ptr *QDateTime) ToOffsetFromUtc(offsetSeconds int) *QDateTime {
|
|
defer qt.Recovering("QDateTime::toOffsetFromUtc")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QDateTime_ToOffsetFromUtc(ptr.Pointer(), C.int(offsetSeconds)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDateTime) ToString2(format Qt__DateFormat) string {
|
|
defer qt.Recovering("QDateTime::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDateTime_ToString2(ptr.Pointer(), C.int(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QDateTime) ToTimeSpec(spec Qt__TimeSpec) *QDateTime {
|
|
defer qt.Recovering("QDateTime::toTimeSpec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QDateTime_ToTimeSpec(ptr.Pointer(), C.int(spec)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQDateTime() *QDateTime {
|
|
defer qt.Recovering("QDateTime::QDateTime")
|
|
|
|
return newQDateTimeFromPointer(C.QDateTime_NewQDateTime())
|
|
}
|
|
|
|
func NewQDateTime2(date QDate_ITF) *QDateTime {
|
|
defer qt.Recovering("QDateTime::QDateTime")
|
|
|
|
return newQDateTimeFromPointer(C.QDateTime_NewQDateTime2(PointerFromQDate(date)))
|
|
}
|
|
|
|
func NewQDateTime3(date QDate_ITF, time QTime_ITF, spec Qt__TimeSpec) *QDateTime {
|
|
defer qt.Recovering("QDateTime::QDateTime")
|
|
|
|
return newQDateTimeFromPointer(C.QDateTime_NewQDateTime3(PointerFromQDate(date), PointerFromQTime(time), C.int(spec)))
|
|
}
|
|
|
|
func NewQDateTime4(date QDate_ITF, time QTime_ITF, spec Qt__TimeSpec, offsetSeconds int) *QDateTime {
|
|
defer qt.Recovering("QDateTime::QDateTime")
|
|
|
|
return newQDateTimeFromPointer(C.QDateTime_NewQDateTime4(PointerFromQDate(date), PointerFromQTime(time), C.int(spec), C.int(offsetSeconds)))
|
|
}
|
|
|
|
func NewQDateTime5(date QDate_ITF, time QTime_ITF, timeZone QTimeZone_ITF) *QDateTime {
|
|
defer qt.Recovering("QDateTime::QDateTime")
|
|
|
|
return newQDateTimeFromPointer(C.QDateTime_NewQDateTime5(PointerFromQDate(date), PointerFromQTime(time), PointerFromQTimeZone(timeZone)))
|
|
}
|
|
|
|
func NewQDateTime6(other QDateTime_ITF) *QDateTime {
|
|
defer qt.Recovering("QDateTime::QDateTime")
|
|
|
|
return newQDateTimeFromPointer(C.QDateTime_NewQDateTime6(PointerFromQDateTime(other)))
|
|
}
|
|
|
|
func (ptr *QDateTime) AddDays(ndays int64) *QDateTime {
|
|
defer qt.Recovering("QDateTime::addDays")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QDateTime_AddDays(ptr.Pointer(), C.longlong(ndays)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDateTime) AddMSecs(msecs int64) *QDateTime {
|
|
defer qt.Recovering("QDateTime::addMSecs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QDateTime_AddMSecs(ptr.Pointer(), C.longlong(msecs)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDateTime) AddMonths(nmonths int) *QDateTime {
|
|
defer qt.Recovering("QDateTime::addMonths")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QDateTime_AddMonths(ptr.Pointer(), C.int(nmonths)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDateTime) AddSecs(s int64) *QDateTime {
|
|
defer qt.Recovering("QDateTime::addSecs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QDateTime_AddSecs(ptr.Pointer(), C.longlong(s)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDateTime) AddYears(nyears int) *QDateTime {
|
|
defer qt.Recovering("QDateTime::addYears")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QDateTime_AddYears(ptr.Pointer(), C.int(nyears)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDateTime) DaysTo(other QDateTime_ITF) int64 {
|
|
defer qt.Recovering("QDateTime::daysTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QDateTime_DaysTo(ptr.Pointer(), PointerFromQDateTime(other)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QDateTime_FromMSecsSinceEpoch(msecs int64) *QDateTime {
|
|
defer qt.Recovering("QDateTime::fromMSecsSinceEpoch")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch(C.longlong(msecs)))
|
|
}
|
|
|
|
func (ptr *QDateTime) FromMSecsSinceEpoch(msecs int64) *QDateTime {
|
|
defer qt.Recovering("QDateTime::fromMSecsSinceEpoch")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch(C.longlong(msecs)))
|
|
}
|
|
|
|
func QDateTime_FromMSecsSinceEpoch2(msecs int64, spec Qt__TimeSpec, offsetSeconds int) *QDateTime {
|
|
defer qt.Recovering("QDateTime::fromMSecsSinceEpoch")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch2(C.longlong(msecs), C.int(spec), C.int(offsetSeconds)))
|
|
}
|
|
|
|
func (ptr *QDateTime) FromMSecsSinceEpoch2(msecs int64, spec Qt__TimeSpec, offsetSeconds int) *QDateTime {
|
|
defer qt.Recovering("QDateTime::fromMSecsSinceEpoch")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch2(C.longlong(msecs), C.int(spec), C.int(offsetSeconds)))
|
|
}
|
|
|
|
func QDateTime_FromMSecsSinceEpoch3(msecs int64, timeZone QTimeZone_ITF) *QDateTime {
|
|
defer qt.Recovering("QDateTime::fromMSecsSinceEpoch")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch3(C.longlong(msecs), PointerFromQTimeZone(timeZone)))
|
|
}
|
|
|
|
func (ptr *QDateTime) FromMSecsSinceEpoch3(msecs int64, timeZone QTimeZone_ITF) *QDateTime {
|
|
defer qt.Recovering("QDateTime::fromMSecsSinceEpoch")
|
|
|
|
return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch3(C.longlong(msecs), PointerFromQTimeZone(timeZone)))
|
|
}
|
|
|
|
func (ptr *QDateTime) IsDaylightTime() bool {
|
|
defer qt.Recovering("QDateTime::isDaylightTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDateTime_IsDaylightTime(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDateTime) IsNull() bool {
|
|
defer qt.Recovering("QDateTime::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDateTime_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDateTime) IsValid() bool {
|
|
defer qt.Recovering("QDateTime::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDateTime_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDateTime) MsecsTo(other QDateTime_ITF) int64 {
|
|
defer qt.Recovering("QDateTime::msecsTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QDateTime_MsecsTo(ptr.Pointer(), PointerFromQDateTime(other)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDateTime) OffsetFromUtc() int {
|
|
defer qt.Recovering("QDateTime::offsetFromUtc")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDateTime_OffsetFromUtc(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDateTime) SecsTo(other QDateTime_ITF) int64 {
|
|
defer qt.Recovering("QDateTime::secsTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QDateTime_SecsTo(ptr.Pointer(), PointerFromQDateTime(other)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDateTime) SetDate(date QDate_ITF) {
|
|
defer qt.Recovering("QDateTime::setDate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDateTime_SetDate(ptr.Pointer(), PointerFromQDate(date))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDateTime) SetMSecsSinceEpoch(msecs int64) {
|
|
defer qt.Recovering("QDateTime::setMSecsSinceEpoch")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDateTime_SetMSecsSinceEpoch(ptr.Pointer(), C.longlong(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDateTime) SetOffsetFromUtc(offsetSeconds int) {
|
|
defer qt.Recovering("QDateTime::setOffsetFromUtc")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDateTime_SetOffsetFromUtc(ptr.Pointer(), C.int(offsetSeconds))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDateTime) SetTime(time QTime_ITF) {
|
|
defer qt.Recovering("QDateTime::setTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDateTime_SetTime(ptr.Pointer(), PointerFromQTime(time))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDateTime) SetTimeSpec(spec Qt__TimeSpec) {
|
|
defer qt.Recovering("QDateTime::setTimeSpec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDateTime_SetTimeSpec(ptr.Pointer(), C.int(spec))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDateTime) SetTimeZone(toZone QTimeZone_ITF) {
|
|
defer qt.Recovering("QDateTime::setTimeZone")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDateTime_SetTimeZone(ptr.Pointer(), PointerFromQTimeZone(toZone))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDateTime) Swap(other QDateTime_ITF) {
|
|
defer qt.Recovering("QDateTime::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDateTime_Swap(ptr.Pointer(), PointerFromQDateTime(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDateTime) TimeSpec() Qt__TimeSpec {
|
|
defer qt.Recovering("QDateTime::timeSpec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__TimeSpec(C.QDateTime_TimeSpec(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDateTime) TimeZone() *QTimeZone {
|
|
defer qt.Recovering("QDateTime::timeZone")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQTimeZoneFromPointer(C.QDateTime_TimeZone(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDateTime) TimeZoneAbbreviation() string {
|
|
defer qt.Recovering("QDateTime::timeZoneAbbreviation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDateTime_TimeZoneAbbreviation(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QDateTime) ToLocalTime() *QDateTime {
|
|
defer qt.Recovering("QDateTime::toLocalTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QDateTime_ToLocalTime(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDateTime) ToMSecsSinceEpoch() int64 {
|
|
defer qt.Recovering("QDateTime::toMSecsSinceEpoch")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QDateTime_ToMSecsSinceEpoch(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDateTime) ToString(format string) string {
|
|
defer qt.Recovering("QDateTime::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDateTime_ToString(ptr.Pointer(), C.CString(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QDateTime) ToTimeZone(timeZone QTimeZone_ITF) *QDateTime {
|
|
defer qt.Recovering("QDateTime::toTimeZone")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QDateTime_ToTimeZone(ptr.Pointer(), PointerFromQTimeZone(timeZone)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDateTime) ToUTC() *QDateTime {
|
|
defer qt.Recovering("QDateTime::toUTC")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QDateTime_ToUTC(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDateTime) DestroyQDateTime() {
|
|
defer qt.Recovering("QDateTime::~QDateTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDateTime_DestroyQDateTime(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QDebug struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QDebug_ITF interface {
|
|
QDebug_PTR() *QDebug
|
|
}
|
|
|
|
func (p *QDebug) QDebug_PTR() *QDebug {
|
|
return p
|
|
}
|
|
|
|
func (p *QDebug) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QDebug) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQDebug(ptr QDebug_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QDebug_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQDebugFromPointer(ptr unsafe.Pointer) *QDebug {
|
|
var n = new(QDebug)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQDebugFromPointer(ptr unsafe.Pointer) *QDebug {
|
|
var n = NewQDebugFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QDebug) DestroyQDebug() {
|
|
defer qt.Recovering("QDebug::~QDebug")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDebug_DestroyQDebug(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func NewQDebug(device QIODevice_ITF) *QDebug {
|
|
defer qt.Recovering("QDebug::QDebug")
|
|
|
|
return newQDebugFromPointer(C.QDebug_NewQDebug(PointerFromQIODevice(device)))
|
|
}
|
|
|
|
func NewQDebug2(stri string) *QDebug {
|
|
defer qt.Recovering("QDebug::QDebug")
|
|
|
|
return newQDebugFromPointer(C.QDebug_NewQDebug2(C.CString(stri)))
|
|
}
|
|
|
|
func NewQDebug4(other QDebug_ITF) *QDebug {
|
|
defer qt.Recovering("QDebug::QDebug")
|
|
|
|
return newQDebugFromPointer(C.QDebug_NewQDebug4(PointerFromQDebug(other)))
|
|
}
|
|
|
|
func (ptr *QDebug) AutoInsertSpaces() bool {
|
|
defer qt.Recovering("QDebug::autoInsertSpaces")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDebug_AutoInsertSpaces(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDebug) MaybeQuote(c string) *QDebug {
|
|
defer qt.Recovering("QDebug::maybeQuote")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QDebug_MaybeQuote(ptr.Pointer(), C.CString(c)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDebug) MaybeSpace() *QDebug {
|
|
defer qt.Recovering("QDebug::maybeSpace")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QDebug_MaybeSpace(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDebug) Noquote() *QDebug {
|
|
defer qt.Recovering("QDebug::noquote")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QDebug_Noquote(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDebug) Nospace() *QDebug {
|
|
defer qt.Recovering("QDebug::nospace")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QDebug_Nospace(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDebug) Quote() *QDebug {
|
|
defer qt.Recovering("QDebug::quote")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QDebug_Quote(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDebug) ResetFormat() *QDebug {
|
|
defer qt.Recovering("QDebug::resetFormat")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QDebug_ResetFormat(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDebug) SetAutoInsertSpaces(b bool) {
|
|
defer qt.Recovering("QDebug::setAutoInsertSpaces")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDebug_SetAutoInsertSpaces(ptr.Pointer(), C.int(qt.GoBoolToInt(b)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDebug) SetVerbosity(verbosityLevel int) {
|
|
defer qt.Recovering("QDebug::setVerbosity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDebug_SetVerbosity(ptr.Pointer(), C.int(verbosityLevel))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDebug) Space() *QDebug {
|
|
defer qt.Recovering("QDebug::space")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QDebug_Space(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QDebug) Swap(other QDebug_ITF) {
|
|
defer qt.Recovering("QDebug::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDebug_Swap(ptr.Pointer(), PointerFromQDebug(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDebug) Verbosity() int {
|
|
defer qt.Recovering("QDebug::verbosity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QDebug_Verbosity(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QDebugStateSaver struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QDebugStateSaver_ITF interface {
|
|
QDebugStateSaver_PTR() *QDebugStateSaver
|
|
}
|
|
|
|
func (p *QDebugStateSaver) QDebugStateSaver_PTR() *QDebugStateSaver {
|
|
return p
|
|
}
|
|
|
|
func (p *QDebugStateSaver) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QDebugStateSaver) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQDebugStateSaver(ptr QDebugStateSaver_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QDebugStateSaver_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQDebugStateSaverFromPointer(ptr unsafe.Pointer) *QDebugStateSaver {
|
|
var n = new(QDebugStateSaver)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQDebugStateSaverFromPointer(ptr unsafe.Pointer) *QDebugStateSaver {
|
|
var n = NewQDebugStateSaverFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQDebugStateSaver(dbg QDebug_ITF) *QDebugStateSaver {
|
|
defer qt.Recovering("QDebugStateSaver::QDebugStateSaver")
|
|
|
|
return newQDebugStateSaverFromPointer(C.QDebugStateSaver_NewQDebugStateSaver(PointerFromQDebug(dbg)))
|
|
}
|
|
|
|
func (ptr *QDebugStateSaver) DestroyQDebugStateSaver() {
|
|
defer qt.Recovering("QDebugStateSaver::~QDebugStateSaver")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDebugStateSaver_DestroyQDebugStateSaver(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QDir::Filter
|
|
type QDir__Filter int64
|
|
|
|
const (
|
|
QDir__Dirs = QDir__Filter(0x001)
|
|
QDir__Files = QDir__Filter(0x002)
|
|
QDir__Drives = QDir__Filter(0x004)
|
|
QDir__NoSymLinks = QDir__Filter(0x008)
|
|
QDir__AllEntries = QDir__Filter(QDir__Dirs | QDir__Files | QDir__Drives)
|
|
QDir__TypeMask = QDir__Filter(0x00f)
|
|
QDir__Readable = QDir__Filter(0x010)
|
|
QDir__Writable = QDir__Filter(0x020)
|
|
QDir__Executable = QDir__Filter(0x040)
|
|
QDir__PermissionMask = QDir__Filter(0x070)
|
|
QDir__Modified = QDir__Filter(0x080)
|
|
QDir__Hidden = QDir__Filter(0x100)
|
|
QDir__System = QDir__Filter(0x200)
|
|
QDir__AccessMask = QDir__Filter(0x3F0)
|
|
QDir__AllDirs = QDir__Filter(0x400)
|
|
QDir__CaseSensitive = QDir__Filter(0x800)
|
|
QDir__NoDot = QDir__Filter(0x2000)
|
|
QDir__NoDotDot = QDir__Filter(0x4000)
|
|
QDir__NoDotAndDotDot = QDir__Filter(QDir__NoDot | QDir__NoDotDot)
|
|
QDir__NoFilter = QDir__Filter(-1)
|
|
)
|
|
|
|
//QDir::SortFlag
|
|
type QDir__SortFlag int64
|
|
|
|
const (
|
|
QDir__Name = QDir__SortFlag(0x00)
|
|
QDir__Time = QDir__SortFlag(0x01)
|
|
QDir__Size = QDir__SortFlag(0x02)
|
|
QDir__Unsorted = QDir__SortFlag(0x03)
|
|
QDir__SortByMask = QDir__SortFlag(0x03)
|
|
QDir__DirsFirst = QDir__SortFlag(0x04)
|
|
QDir__Reversed = QDir__SortFlag(0x08)
|
|
QDir__IgnoreCase = QDir__SortFlag(0x10)
|
|
QDir__DirsLast = QDir__SortFlag(0x20)
|
|
QDir__LocaleAware = QDir__SortFlag(0x40)
|
|
QDir__Type = QDir__SortFlag(0x80)
|
|
QDir__NoSort = QDir__SortFlag(-1)
|
|
)
|
|
|
|
type QDir struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QDir_ITF interface {
|
|
QDir_PTR() *QDir
|
|
}
|
|
|
|
func (p *QDir) QDir_PTR() *QDir {
|
|
return p
|
|
}
|
|
|
|
func (p *QDir) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QDir) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQDir(ptr QDir_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QDir_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQDirFromPointer(ptr unsafe.Pointer) *QDir {
|
|
var n = new(QDir)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQDirFromPointer(ptr unsafe.Pointer) *QDir {
|
|
var n = NewQDirFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQDir(dir QDir_ITF) *QDir {
|
|
defer qt.Recovering("QDir::QDir")
|
|
|
|
return newQDirFromPointer(C.QDir_NewQDir(PointerFromQDir(dir)))
|
|
}
|
|
|
|
func NewQDir2(path string) *QDir {
|
|
defer qt.Recovering("QDir::QDir")
|
|
|
|
return newQDirFromPointer(C.QDir_NewQDir2(C.CString(path)))
|
|
}
|
|
|
|
func NewQDir3(path string, nameFilter string, sort QDir__SortFlag, filters QDir__Filter) *QDir {
|
|
defer qt.Recovering("QDir::QDir")
|
|
|
|
return newQDirFromPointer(C.QDir_NewQDir3(C.CString(path), C.CString(nameFilter), C.int(sort), C.int(filters)))
|
|
}
|
|
|
|
func (ptr *QDir) AbsoluteFilePath(fileName string) string {
|
|
defer qt.Recovering("QDir::absoluteFilePath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDir_AbsoluteFilePath(ptr.Pointer(), C.CString(fileName)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QDir) AbsolutePath() string {
|
|
defer qt.Recovering("QDir::absolutePath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDir_AbsolutePath(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func QDir_AddSearchPath(prefix string, path string) {
|
|
defer qt.Recovering("QDir::addSearchPath")
|
|
|
|
C.QDir_QDir_AddSearchPath(C.CString(prefix), C.CString(path))
|
|
}
|
|
|
|
func (ptr *QDir) AddSearchPath(prefix string, path string) {
|
|
defer qt.Recovering("QDir::addSearchPath")
|
|
|
|
C.QDir_QDir_AddSearchPath(C.CString(prefix), C.CString(path))
|
|
}
|
|
|
|
func (ptr *QDir) CanonicalPath() string {
|
|
defer qt.Recovering("QDir::canonicalPath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDir_CanonicalPath(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QDir) Cd(dirName string) bool {
|
|
defer qt.Recovering("QDir::cd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_Cd(ptr.Pointer(), C.CString(dirName)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDir) CdUp() bool {
|
|
defer qt.Recovering("QDir::cdUp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_CdUp(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QDir_CleanPath(path string) string {
|
|
defer qt.Recovering("QDir::cleanPath")
|
|
|
|
return C.GoString(C.QDir_QDir_CleanPath(C.CString(path)))
|
|
}
|
|
|
|
func (ptr *QDir) CleanPath(path string) string {
|
|
defer qt.Recovering("QDir::cleanPath")
|
|
|
|
return C.GoString(C.QDir_QDir_CleanPath(C.CString(path)))
|
|
}
|
|
|
|
func QDir_Current() *QDir {
|
|
defer qt.Recovering("QDir::current")
|
|
|
|
return NewQDirFromPointer(C.QDir_QDir_Current())
|
|
}
|
|
|
|
func (ptr *QDir) Current() *QDir {
|
|
defer qt.Recovering("QDir::current")
|
|
|
|
return NewQDirFromPointer(C.QDir_QDir_Current())
|
|
}
|
|
|
|
func QDir_CurrentPath() string {
|
|
defer qt.Recovering("QDir::currentPath")
|
|
|
|
return C.GoString(C.QDir_QDir_CurrentPath())
|
|
}
|
|
|
|
func (ptr *QDir) CurrentPath() string {
|
|
defer qt.Recovering("QDir::currentPath")
|
|
|
|
return C.GoString(C.QDir_QDir_CurrentPath())
|
|
}
|
|
|
|
func (ptr *QDir) DirName() string {
|
|
defer qt.Recovering("QDir::dirName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDir_DirName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QDir) EntryList2(filters QDir__Filter, sort QDir__SortFlag) []string {
|
|
defer qt.Recovering("QDir::entryList")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QDir_EntryList2(ptr.Pointer(), C.int(filters), C.int(sort))), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QDir) EntryList(nameFilters []string, filters QDir__Filter, sort QDir__SortFlag) []string {
|
|
defer qt.Recovering("QDir::entryList")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QDir_EntryList(ptr.Pointer(), C.CString(strings.Join(nameFilters, "|")), C.int(filters), C.int(sort))), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QDir) Exists2() bool {
|
|
defer qt.Recovering("QDir::exists")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_Exists2(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDir) Exists(name string) bool {
|
|
defer qt.Recovering("QDir::exists")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_Exists(ptr.Pointer(), C.CString(name)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDir) FilePath(fileName string) string {
|
|
defer qt.Recovering("QDir::filePath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDir_FilePath(ptr.Pointer(), C.CString(fileName)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QDir) Filter() QDir__Filter {
|
|
defer qt.Recovering("QDir::filter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QDir__Filter(C.QDir_Filter(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QDir_FromNativeSeparators(pathName string) string {
|
|
defer qt.Recovering("QDir::fromNativeSeparators")
|
|
|
|
return C.GoString(C.QDir_QDir_FromNativeSeparators(C.CString(pathName)))
|
|
}
|
|
|
|
func (ptr *QDir) FromNativeSeparators(pathName string) string {
|
|
defer qt.Recovering("QDir::fromNativeSeparators")
|
|
|
|
return C.GoString(C.QDir_QDir_FromNativeSeparators(C.CString(pathName)))
|
|
}
|
|
|
|
func QDir_Home() *QDir {
|
|
defer qt.Recovering("QDir::home")
|
|
|
|
return NewQDirFromPointer(C.QDir_QDir_Home())
|
|
}
|
|
|
|
func (ptr *QDir) Home() *QDir {
|
|
defer qt.Recovering("QDir::home")
|
|
|
|
return NewQDirFromPointer(C.QDir_QDir_Home())
|
|
}
|
|
|
|
func QDir_HomePath() string {
|
|
defer qt.Recovering("QDir::homePath")
|
|
|
|
return C.GoString(C.QDir_QDir_HomePath())
|
|
}
|
|
|
|
func (ptr *QDir) HomePath() string {
|
|
defer qt.Recovering("QDir::homePath")
|
|
|
|
return C.GoString(C.QDir_QDir_HomePath())
|
|
}
|
|
|
|
func (ptr *QDir) IsAbsolute() bool {
|
|
defer qt.Recovering("QDir::isAbsolute")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_IsAbsolute(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QDir_IsAbsolutePath(path string) bool {
|
|
defer qt.Recovering("QDir::isAbsolutePath")
|
|
|
|
return C.QDir_QDir_IsAbsolutePath(C.CString(path)) != 0
|
|
}
|
|
|
|
func (ptr *QDir) IsAbsolutePath(path string) bool {
|
|
defer qt.Recovering("QDir::isAbsolutePath")
|
|
|
|
return C.QDir_QDir_IsAbsolutePath(C.CString(path)) != 0
|
|
}
|
|
|
|
func (ptr *QDir) IsReadable() bool {
|
|
defer qt.Recovering("QDir::isReadable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_IsReadable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDir) IsRelative() bool {
|
|
defer qt.Recovering("QDir::isRelative")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_IsRelative(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QDir_IsRelativePath(path string) bool {
|
|
defer qt.Recovering("QDir::isRelativePath")
|
|
|
|
return C.QDir_QDir_IsRelativePath(C.CString(path)) != 0
|
|
}
|
|
|
|
func (ptr *QDir) IsRelativePath(path string) bool {
|
|
defer qt.Recovering("QDir::isRelativePath")
|
|
|
|
return C.QDir_QDir_IsRelativePath(C.CString(path)) != 0
|
|
}
|
|
|
|
func (ptr *QDir) IsRoot() bool {
|
|
defer qt.Recovering("QDir::isRoot")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_IsRoot(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDir) MakeAbsolute() bool {
|
|
defer qt.Recovering("QDir::makeAbsolute")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_MakeAbsolute(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QDir_Match(filter string, fileName string) bool {
|
|
defer qt.Recovering("QDir::match")
|
|
|
|
return C.QDir_QDir_Match(C.CString(filter), C.CString(fileName)) != 0
|
|
}
|
|
|
|
func (ptr *QDir) Match(filter string, fileName string) bool {
|
|
defer qt.Recovering("QDir::match")
|
|
|
|
return C.QDir_QDir_Match(C.CString(filter), C.CString(fileName)) != 0
|
|
}
|
|
|
|
func QDir_Match2(filters []string, fileName string) bool {
|
|
defer qt.Recovering("QDir::match")
|
|
|
|
return C.QDir_QDir_Match2(C.CString(strings.Join(filters, "|")), C.CString(fileName)) != 0
|
|
}
|
|
|
|
func (ptr *QDir) Match2(filters []string, fileName string) bool {
|
|
defer qt.Recovering("QDir::match")
|
|
|
|
return C.QDir_QDir_Match2(C.CString(strings.Join(filters, "|")), C.CString(fileName)) != 0
|
|
}
|
|
|
|
func (ptr *QDir) Mkdir(dirName string) bool {
|
|
defer qt.Recovering("QDir::mkdir")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_Mkdir(ptr.Pointer(), C.CString(dirName)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDir) Mkpath(dirPath string) bool {
|
|
defer qt.Recovering("QDir::mkpath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_Mkpath(ptr.Pointer(), C.CString(dirPath)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDir) NameFilters() []string {
|
|
defer qt.Recovering("QDir::nameFilters")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QDir_NameFilters(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QDir) Path() string {
|
|
defer qt.Recovering("QDir::path")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDir_Path(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QDir) Refresh() {
|
|
defer qt.Recovering("QDir::refresh")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDir_Refresh(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QDir) RelativeFilePath(fileName string) string {
|
|
defer qt.Recovering("QDir::relativeFilePath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDir_RelativeFilePath(ptr.Pointer(), C.CString(fileName)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QDir) Remove(fileName string) bool {
|
|
defer qt.Recovering("QDir::remove")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_Remove(ptr.Pointer(), C.CString(fileName)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDir) RemoveRecursively() bool {
|
|
defer qt.Recovering("QDir::removeRecursively")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_RemoveRecursively(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDir) Rename(oldName string, newName string) bool {
|
|
defer qt.Recovering("QDir::rename")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_Rename(ptr.Pointer(), C.CString(oldName), C.CString(newName)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDir) Rmdir(dirName string) bool {
|
|
defer qt.Recovering("QDir::rmdir")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_Rmdir(ptr.Pointer(), C.CString(dirName)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QDir) Rmpath(dirPath string) bool {
|
|
defer qt.Recovering("QDir::rmpath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QDir_Rmpath(ptr.Pointer(), C.CString(dirPath)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QDir_Root() *QDir {
|
|
defer qt.Recovering("QDir::root")
|
|
|
|
return NewQDirFromPointer(C.QDir_QDir_Root())
|
|
}
|
|
|
|
func (ptr *QDir) Root() *QDir {
|
|
defer qt.Recovering("QDir::root")
|
|
|
|
return NewQDirFromPointer(C.QDir_QDir_Root())
|
|
}
|
|
|
|
func QDir_RootPath() string {
|
|
defer qt.Recovering("QDir::rootPath")
|
|
|
|
return C.GoString(C.QDir_QDir_RootPath())
|
|
}
|
|
|
|
func (ptr *QDir) RootPath() string {
|
|
defer qt.Recovering("QDir::rootPath")
|
|
|
|
return C.GoString(C.QDir_QDir_RootPath())
|
|
}
|
|
|
|
func QDir_SearchPaths(prefix string) []string {
|
|
defer qt.Recovering("QDir::searchPaths")
|
|
|
|
return strings.Split(C.GoString(C.QDir_QDir_SearchPaths(C.CString(prefix))), "|")
|
|
}
|
|
|
|
func (ptr *QDir) SearchPaths(prefix string) []string {
|
|
defer qt.Recovering("QDir::searchPaths")
|
|
|
|
return strings.Split(C.GoString(C.QDir_QDir_SearchPaths(C.CString(prefix))), "|")
|
|
}
|
|
|
|
func QDir_SetCurrent(path string) bool {
|
|
defer qt.Recovering("QDir::setCurrent")
|
|
|
|
return C.QDir_QDir_SetCurrent(C.CString(path)) != 0
|
|
}
|
|
|
|
func (ptr *QDir) SetCurrent(path string) bool {
|
|
defer qt.Recovering("QDir::setCurrent")
|
|
|
|
return C.QDir_QDir_SetCurrent(C.CString(path)) != 0
|
|
}
|
|
|
|
func (ptr *QDir) SetFilter(filters QDir__Filter) {
|
|
defer qt.Recovering("QDir::setFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDir_SetFilter(ptr.Pointer(), C.int(filters))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDir) SetNameFilters(nameFilters []string) {
|
|
defer qt.Recovering("QDir::setNameFilters")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDir_SetNameFilters(ptr.Pointer(), C.CString(strings.Join(nameFilters, "|")))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDir) SetPath(path string) {
|
|
defer qt.Recovering("QDir::setPath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDir_SetPath(ptr.Pointer(), C.CString(path))
|
|
}
|
|
}
|
|
|
|
func QDir_SetSearchPaths(prefix string, searchPaths []string) {
|
|
defer qt.Recovering("QDir::setSearchPaths")
|
|
|
|
C.QDir_QDir_SetSearchPaths(C.CString(prefix), C.CString(strings.Join(searchPaths, "|")))
|
|
}
|
|
|
|
func (ptr *QDir) SetSearchPaths(prefix string, searchPaths []string) {
|
|
defer qt.Recovering("QDir::setSearchPaths")
|
|
|
|
C.QDir_QDir_SetSearchPaths(C.CString(prefix), C.CString(strings.Join(searchPaths, "|")))
|
|
}
|
|
|
|
func (ptr *QDir) SetSorting(sort QDir__SortFlag) {
|
|
defer qt.Recovering("QDir::setSorting")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDir_SetSorting(ptr.Pointer(), C.int(sort))
|
|
}
|
|
}
|
|
|
|
func (ptr *QDir) Sorting() QDir__SortFlag {
|
|
defer qt.Recovering("QDir::sorting")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QDir__SortFlag(C.QDir_Sorting(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QDir) Swap(other QDir_ITF) {
|
|
defer qt.Recovering("QDir::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDir_Swap(ptr.Pointer(), PointerFromQDir(other))
|
|
}
|
|
}
|
|
|
|
func QDir_Temp() *QDir {
|
|
defer qt.Recovering("QDir::temp")
|
|
|
|
return NewQDirFromPointer(C.QDir_QDir_Temp())
|
|
}
|
|
|
|
func (ptr *QDir) Temp() *QDir {
|
|
defer qt.Recovering("QDir::temp")
|
|
|
|
return NewQDirFromPointer(C.QDir_QDir_Temp())
|
|
}
|
|
|
|
func QDir_TempPath() string {
|
|
defer qt.Recovering("QDir::tempPath")
|
|
|
|
return C.GoString(C.QDir_QDir_TempPath())
|
|
}
|
|
|
|
func (ptr *QDir) TempPath() string {
|
|
defer qt.Recovering("QDir::tempPath")
|
|
|
|
return C.GoString(C.QDir_QDir_TempPath())
|
|
}
|
|
|
|
func QDir_ToNativeSeparators(pathName string) string {
|
|
defer qt.Recovering("QDir::toNativeSeparators")
|
|
|
|
return C.GoString(C.QDir_QDir_ToNativeSeparators(C.CString(pathName)))
|
|
}
|
|
|
|
func (ptr *QDir) ToNativeSeparators(pathName string) string {
|
|
defer qt.Recovering("QDir::toNativeSeparators")
|
|
|
|
return C.GoString(C.QDir_QDir_ToNativeSeparators(C.CString(pathName)))
|
|
}
|
|
|
|
func (ptr *QDir) DestroyQDir() {
|
|
defer qt.Recovering("QDir::~QDir")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QDir_DestroyQDir(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QDirIterator::IteratorFlag
|
|
type QDirIterator__IteratorFlag int64
|
|
|
|
const (
|
|
QDirIterator__NoIteratorFlags = QDirIterator__IteratorFlag(0x0)
|
|
QDirIterator__FollowSymlinks = QDirIterator__IteratorFlag(0x1)
|
|
QDirIterator__Subdirectories = QDirIterator__IteratorFlag(0x2)
|
|
)
|
|
|
|
type QDirIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QDirIterator_ITF interface {
|
|
QDirIterator_PTR() *QDirIterator
|
|
}
|
|
|
|
func (p *QDirIterator) QDirIterator_PTR() *QDirIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QDirIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QDirIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQDirIterator(ptr QDirIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QDirIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQDirIteratorFromPointer(ptr unsafe.Pointer) *QDirIterator {
|
|
var n = new(QDirIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQDirIteratorFromPointer(ptr unsafe.Pointer) *QDirIterator {
|
|
var n = NewQDirIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QDynamicPropertyChangeEvent struct {
|
|
QEvent
|
|
}
|
|
|
|
type QDynamicPropertyChangeEvent_ITF interface {
|
|
QEvent_ITF
|
|
QDynamicPropertyChangeEvent_PTR() *QDynamicPropertyChangeEvent
|
|
}
|
|
|
|
func (p *QDynamicPropertyChangeEvent) QDynamicPropertyChangeEvent_PTR() *QDynamicPropertyChangeEvent {
|
|
return p
|
|
}
|
|
|
|
func (p *QDynamicPropertyChangeEvent) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QEvent_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QDynamicPropertyChangeEvent) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QEvent_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQDynamicPropertyChangeEvent(ptr QDynamicPropertyChangeEvent_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QDynamicPropertyChangeEvent_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQDynamicPropertyChangeEventFromPointer(ptr unsafe.Pointer) *QDynamicPropertyChangeEvent {
|
|
var n = new(QDynamicPropertyChangeEvent)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQDynamicPropertyChangeEventFromPointer(ptr unsafe.Pointer) *QDynamicPropertyChangeEvent {
|
|
var n = NewQDynamicPropertyChangeEventFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQDynamicPropertyChangeEvent(name string) *QDynamicPropertyChangeEvent {
|
|
defer qt.Recovering("QDynamicPropertyChangeEvent::QDynamicPropertyChangeEvent")
|
|
|
|
return newQDynamicPropertyChangeEventFromPointer(C.QDynamicPropertyChangeEvent_NewQDynamicPropertyChangeEvent(C.CString(name)))
|
|
}
|
|
|
|
func (ptr *QDynamicPropertyChangeEvent) PropertyName() string {
|
|
defer qt.Recovering("QDynamicPropertyChangeEvent::propertyName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QDynamicPropertyChangeEvent_PropertyName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//QEasingCurve::Type
|
|
type QEasingCurve__Type int64
|
|
|
|
const (
|
|
QEasingCurve__Linear = QEasingCurve__Type(0)
|
|
QEasingCurve__InQuad = QEasingCurve__Type(1)
|
|
QEasingCurve__OutQuad = QEasingCurve__Type(2)
|
|
QEasingCurve__InOutQuad = QEasingCurve__Type(3)
|
|
QEasingCurve__OutInQuad = QEasingCurve__Type(4)
|
|
QEasingCurve__InCubic = QEasingCurve__Type(5)
|
|
QEasingCurve__OutCubic = QEasingCurve__Type(6)
|
|
QEasingCurve__InOutCubic = QEasingCurve__Type(7)
|
|
QEasingCurve__OutInCubic = QEasingCurve__Type(8)
|
|
QEasingCurve__InQuart = QEasingCurve__Type(9)
|
|
QEasingCurve__OutQuart = QEasingCurve__Type(10)
|
|
QEasingCurve__InOutQuart = QEasingCurve__Type(11)
|
|
QEasingCurve__OutInQuart = QEasingCurve__Type(12)
|
|
QEasingCurve__InQuint = QEasingCurve__Type(13)
|
|
QEasingCurve__OutQuint = QEasingCurve__Type(14)
|
|
QEasingCurve__InOutQuint = QEasingCurve__Type(15)
|
|
QEasingCurve__OutInQuint = QEasingCurve__Type(16)
|
|
QEasingCurve__InSine = QEasingCurve__Type(17)
|
|
QEasingCurve__OutSine = QEasingCurve__Type(18)
|
|
QEasingCurve__InOutSine = QEasingCurve__Type(19)
|
|
QEasingCurve__OutInSine = QEasingCurve__Type(20)
|
|
QEasingCurve__InExpo = QEasingCurve__Type(21)
|
|
QEasingCurve__OutExpo = QEasingCurve__Type(22)
|
|
QEasingCurve__InOutExpo = QEasingCurve__Type(23)
|
|
QEasingCurve__OutInExpo = QEasingCurve__Type(24)
|
|
QEasingCurve__InCirc = QEasingCurve__Type(25)
|
|
QEasingCurve__OutCirc = QEasingCurve__Type(26)
|
|
QEasingCurve__InOutCirc = QEasingCurve__Type(27)
|
|
QEasingCurve__OutInCirc = QEasingCurve__Type(28)
|
|
QEasingCurve__InElastic = QEasingCurve__Type(29)
|
|
QEasingCurve__OutElastic = QEasingCurve__Type(30)
|
|
QEasingCurve__InOutElastic = QEasingCurve__Type(31)
|
|
QEasingCurve__OutInElastic = QEasingCurve__Type(32)
|
|
QEasingCurve__InBack = QEasingCurve__Type(33)
|
|
QEasingCurve__OutBack = QEasingCurve__Type(34)
|
|
QEasingCurve__InOutBack = QEasingCurve__Type(35)
|
|
QEasingCurve__OutInBack = QEasingCurve__Type(36)
|
|
QEasingCurve__InBounce = QEasingCurve__Type(37)
|
|
QEasingCurve__OutBounce = QEasingCurve__Type(38)
|
|
QEasingCurve__InOutBounce = QEasingCurve__Type(39)
|
|
QEasingCurve__OutInBounce = QEasingCurve__Type(40)
|
|
QEasingCurve__InCurve = QEasingCurve__Type(41)
|
|
QEasingCurve__OutCurve = QEasingCurve__Type(42)
|
|
QEasingCurve__SineCurve = QEasingCurve__Type(43)
|
|
QEasingCurve__CosineCurve = QEasingCurve__Type(44)
|
|
QEasingCurve__BezierSpline = QEasingCurve__Type(45)
|
|
QEasingCurve__TCBSpline = QEasingCurve__Type(46)
|
|
QEasingCurve__Custom = QEasingCurve__Type(47)
|
|
QEasingCurve__NCurveTypes = QEasingCurve__Type(48)
|
|
)
|
|
|
|
type QEasingCurve struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QEasingCurve_ITF interface {
|
|
QEasingCurve_PTR() *QEasingCurve
|
|
}
|
|
|
|
func (p *QEasingCurve) QEasingCurve_PTR() *QEasingCurve {
|
|
return p
|
|
}
|
|
|
|
func (p *QEasingCurve) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QEasingCurve) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQEasingCurve(ptr QEasingCurve_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QEasingCurve_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQEasingCurveFromPointer(ptr unsafe.Pointer) *QEasingCurve {
|
|
var n = new(QEasingCurve)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQEasingCurveFromPointer(ptr unsafe.Pointer) *QEasingCurve {
|
|
var n = NewQEasingCurveFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQEasingCurve3(other QEasingCurve_ITF) *QEasingCurve {
|
|
defer qt.Recovering("QEasingCurve::QEasingCurve")
|
|
|
|
return newQEasingCurveFromPointer(C.QEasingCurve_NewQEasingCurve3(PointerFromQEasingCurve(other)))
|
|
}
|
|
|
|
func NewQEasingCurve(ty QEasingCurve__Type) *QEasingCurve {
|
|
defer qt.Recovering("QEasingCurve::QEasingCurve")
|
|
|
|
return newQEasingCurveFromPointer(C.QEasingCurve_NewQEasingCurve(C.int(ty)))
|
|
}
|
|
|
|
func NewQEasingCurve2(other QEasingCurve_ITF) *QEasingCurve {
|
|
defer qt.Recovering("QEasingCurve::QEasingCurve")
|
|
|
|
return newQEasingCurveFromPointer(C.QEasingCurve_NewQEasingCurve2(PointerFromQEasingCurve(other)))
|
|
}
|
|
|
|
func (ptr *QEasingCurve) AddCubicBezierSegment(c1 QPointF_ITF, c2 QPointF_ITF, endPoint QPointF_ITF) {
|
|
defer qt.Recovering("QEasingCurve::addCubicBezierSegment")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEasingCurve_AddCubicBezierSegment(ptr.Pointer(), PointerFromQPointF(c1), PointerFromQPointF(c2), PointerFromQPointF(endPoint))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEasingCurve) AddTCBSegment(nextPoint QPointF_ITF, t float64, c float64, b float64) {
|
|
defer qt.Recovering("QEasingCurve::addTCBSegment")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEasingCurve_AddTCBSegment(ptr.Pointer(), PointerFromQPointF(nextPoint), C.double(t), C.double(c), C.double(b))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEasingCurve) Amplitude() float64 {
|
|
defer qt.Recovering("QEasingCurve::amplitude")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QEasingCurve_Amplitude(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QEasingCurve) Overshoot() float64 {
|
|
defer qt.Recovering("QEasingCurve::overshoot")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QEasingCurve_Overshoot(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QEasingCurve) Period() float64 {
|
|
defer qt.Recovering("QEasingCurve::period")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QEasingCurve_Period(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QEasingCurve) SetAmplitude(amplitude float64) {
|
|
defer qt.Recovering("QEasingCurve::setAmplitude")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEasingCurve_SetAmplitude(ptr.Pointer(), C.double(amplitude))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEasingCurve) SetOvershoot(overshoot float64) {
|
|
defer qt.Recovering("QEasingCurve::setOvershoot")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEasingCurve_SetOvershoot(ptr.Pointer(), C.double(overshoot))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEasingCurve) SetPeriod(period float64) {
|
|
defer qt.Recovering("QEasingCurve::setPeriod")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEasingCurve_SetPeriod(ptr.Pointer(), C.double(period))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEasingCurve) SetType(ty QEasingCurve__Type) {
|
|
defer qt.Recovering("QEasingCurve::setType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEasingCurve_SetType(ptr.Pointer(), C.int(ty))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEasingCurve) Swap(other QEasingCurve_ITF) {
|
|
defer qt.Recovering("QEasingCurve::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEasingCurve_Swap(ptr.Pointer(), PointerFromQEasingCurve(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEasingCurve) Type() QEasingCurve__Type {
|
|
defer qt.Recovering("QEasingCurve::type")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QEasingCurve__Type(C.QEasingCurve_Type(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QEasingCurve) ValueForProgress(progress float64) float64 {
|
|
defer qt.Recovering("QEasingCurve::valueForProgress")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QEasingCurve_ValueForProgress(ptr.Pointer(), C.double(progress)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QEasingCurve) DestroyQEasingCurve() {
|
|
defer qt.Recovering("QEasingCurve::~QEasingCurve")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEasingCurve_DestroyQEasingCurve(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QElapsedTimer::ClockType
|
|
type QElapsedTimer__ClockType int64
|
|
|
|
const (
|
|
QElapsedTimer__SystemTime = QElapsedTimer__ClockType(0)
|
|
QElapsedTimer__MonotonicClock = QElapsedTimer__ClockType(1)
|
|
QElapsedTimer__TickCounter = QElapsedTimer__ClockType(2)
|
|
QElapsedTimer__MachAbsoluteTime = QElapsedTimer__ClockType(3)
|
|
QElapsedTimer__PerformanceCounter = QElapsedTimer__ClockType(4)
|
|
)
|
|
|
|
type QElapsedTimer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QElapsedTimer_ITF interface {
|
|
QElapsedTimer_PTR() *QElapsedTimer
|
|
}
|
|
|
|
func (p *QElapsedTimer) QElapsedTimer_PTR() *QElapsedTimer {
|
|
return p
|
|
}
|
|
|
|
func (p *QElapsedTimer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QElapsedTimer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQElapsedTimer(ptr QElapsedTimer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QElapsedTimer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQElapsedTimerFromPointer(ptr unsafe.Pointer) *QElapsedTimer {
|
|
var n = new(QElapsedTimer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQElapsedTimerFromPointer(ptr unsafe.Pointer) *QElapsedTimer {
|
|
var n = NewQElapsedTimerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQElapsedTimer() *QElapsedTimer {
|
|
defer qt.Recovering("QElapsedTimer::QElapsedTimer")
|
|
|
|
return newQElapsedTimerFromPointer(C.QElapsedTimer_NewQElapsedTimer())
|
|
}
|
|
|
|
func (ptr *QElapsedTimer) HasExpired(timeout int64) bool {
|
|
defer qt.Recovering("QElapsedTimer::hasExpired")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QElapsedTimer_HasExpired(ptr.Pointer(), C.longlong(timeout)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QElapsedTimer) Invalidate() {
|
|
defer qt.Recovering("QElapsedTimer::invalidate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QElapsedTimer_Invalidate(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QElapsedTimer) IsValid() bool {
|
|
defer qt.Recovering("QElapsedTimer::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QElapsedTimer_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QElapsedTimer_ClockType() QElapsedTimer__ClockType {
|
|
defer qt.Recovering("QElapsedTimer::clockType")
|
|
|
|
return QElapsedTimer__ClockType(C.QElapsedTimer_QElapsedTimer_ClockType())
|
|
}
|
|
|
|
func (ptr *QElapsedTimer) ClockType() QElapsedTimer__ClockType {
|
|
defer qt.Recovering("QElapsedTimer::clockType")
|
|
|
|
return QElapsedTimer__ClockType(C.QElapsedTimer_QElapsedTimer_ClockType())
|
|
}
|
|
|
|
func (ptr *QElapsedTimer) Elapsed() int64 {
|
|
defer qt.Recovering("QElapsedTimer::elapsed")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QElapsedTimer_Elapsed(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QElapsedTimer_IsMonotonic() bool {
|
|
defer qt.Recovering("QElapsedTimer::isMonotonic")
|
|
|
|
return C.QElapsedTimer_QElapsedTimer_IsMonotonic() != 0
|
|
}
|
|
|
|
func (ptr *QElapsedTimer) IsMonotonic() bool {
|
|
defer qt.Recovering("QElapsedTimer::isMonotonic")
|
|
|
|
return C.QElapsedTimer_QElapsedTimer_IsMonotonic() != 0
|
|
}
|
|
|
|
func (ptr *QElapsedTimer) MsecsSinceReference() int64 {
|
|
defer qt.Recovering("QElapsedTimer::msecsSinceReference")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QElapsedTimer_MsecsSinceReference(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QElapsedTimer) MsecsTo(other QElapsedTimer_ITF) int64 {
|
|
defer qt.Recovering("QElapsedTimer::msecsTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QElapsedTimer_MsecsTo(ptr.Pointer(), PointerFromQElapsedTimer(other)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QElapsedTimer) NsecsElapsed() int64 {
|
|
defer qt.Recovering("QElapsedTimer::nsecsElapsed")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QElapsedTimer_NsecsElapsed(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QElapsedTimer) Restart() int64 {
|
|
defer qt.Recovering("QElapsedTimer::restart")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QElapsedTimer_Restart(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QElapsedTimer) SecsTo(other QElapsedTimer_ITF) int64 {
|
|
defer qt.Recovering("QElapsedTimer::secsTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QElapsedTimer_SecsTo(ptr.Pointer(), PointerFromQElapsedTimer(other)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QElapsedTimer) Start() {
|
|
defer qt.Recovering("QElapsedTimer::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QElapsedTimer_Start(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
type QEnableSharedFromThis struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QEnableSharedFromThis_ITF interface {
|
|
QEnableSharedFromThis_PTR() *QEnableSharedFromThis
|
|
}
|
|
|
|
func (p *QEnableSharedFromThis) QEnableSharedFromThis_PTR() *QEnableSharedFromThis {
|
|
return p
|
|
}
|
|
|
|
func (p *QEnableSharedFromThis) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QEnableSharedFromThis) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQEnableSharedFromThis(ptr QEnableSharedFromThis_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QEnableSharedFromThis_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQEnableSharedFromThisFromPointer(ptr unsafe.Pointer) *QEnableSharedFromThis {
|
|
var n = new(QEnableSharedFromThis)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQEnableSharedFromThisFromPointer(ptr unsafe.Pointer) *QEnableSharedFromThis {
|
|
var n = NewQEnableSharedFromThisFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QEvent::Type
|
|
type QEvent__Type int64
|
|
|
|
const (
|
|
QEvent__None = QEvent__Type(0)
|
|
QEvent__Timer = QEvent__Type(1)
|
|
QEvent__MouseButtonPress = QEvent__Type(2)
|
|
QEvent__MouseButtonRelease = QEvent__Type(3)
|
|
QEvent__MouseButtonDblClick = QEvent__Type(4)
|
|
QEvent__MouseMove = QEvent__Type(5)
|
|
QEvent__KeyPress = QEvent__Type(6)
|
|
QEvent__KeyRelease = QEvent__Type(7)
|
|
QEvent__FocusIn = QEvent__Type(8)
|
|
QEvent__FocusOut = QEvent__Type(9)
|
|
QEvent__FocusAboutToChange = QEvent__Type(23)
|
|
QEvent__Enter = QEvent__Type(10)
|
|
QEvent__Leave = QEvent__Type(11)
|
|
QEvent__Paint = QEvent__Type(12)
|
|
QEvent__Move = QEvent__Type(13)
|
|
QEvent__Resize = QEvent__Type(14)
|
|
QEvent__Create = QEvent__Type(15)
|
|
QEvent__Destroy = QEvent__Type(16)
|
|
QEvent__Show = QEvent__Type(17)
|
|
QEvent__Hide = QEvent__Type(18)
|
|
QEvent__Close = QEvent__Type(19)
|
|
QEvent__Quit = QEvent__Type(20)
|
|
QEvent__ParentChange = QEvent__Type(21)
|
|
QEvent__ParentAboutToChange = QEvent__Type(131)
|
|
QEvent__ThreadChange = QEvent__Type(22)
|
|
QEvent__WindowActivate = QEvent__Type(24)
|
|
QEvent__WindowDeactivate = QEvent__Type(25)
|
|
QEvent__ShowToParent = QEvent__Type(26)
|
|
QEvent__HideToParent = QEvent__Type(27)
|
|
QEvent__Wheel = QEvent__Type(31)
|
|
QEvent__WindowTitleChange = QEvent__Type(33)
|
|
QEvent__WindowIconChange = QEvent__Type(34)
|
|
QEvent__ApplicationWindowIconChange = QEvent__Type(35)
|
|
QEvent__ApplicationFontChange = QEvent__Type(36)
|
|
QEvent__ApplicationLayoutDirectionChange = QEvent__Type(37)
|
|
QEvent__ApplicationPaletteChange = QEvent__Type(38)
|
|
QEvent__PaletteChange = QEvent__Type(39)
|
|
QEvent__Clipboard = QEvent__Type(40)
|
|
QEvent__Speech = QEvent__Type(42)
|
|
QEvent__MetaCall = QEvent__Type(43)
|
|
QEvent__SockAct = QEvent__Type(50)
|
|
QEvent__WinEventAct = QEvent__Type(132)
|
|
QEvent__DeferredDelete = QEvent__Type(52)
|
|
QEvent__DragEnter = QEvent__Type(60)
|
|
QEvent__DragMove = QEvent__Type(61)
|
|
QEvent__DragLeave = QEvent__Type(62)
|
|
QEvent__Drop = QEvent__Type(63)
|
|
QEvent__DragResponse = QEvent__Type(64)
|
|
QEvent__ChildAdded = QEvent__Type(68)
|
|
QEvent__ChildPolished = QEvent__Type(69)
|
|
QEvent__ChildRemoved = QEvent__Type(71)
|
|
QEvent__ShowWindowRequest = QEvent__Type(73)
|
|
QEvent__PolishRequest = QEvent__Type(74)
|
|
QEvent__Polish = QEvent__Type(75)
|
|
QEvent__LayoutRequest = QEvent__Type(76)
|
|
QEvent__UpdateRequest = QEvent__Type(77)
|
|
QEvent__UpdateLater = QEvent__Type(78)
|
|
QEvent__EmbeddingControl = QEvent__Type(79)
|
|
QEvent__ActivateControl = QEvent__Type(80)
|
|
QEvent__DeactivateControl = QEvent__Type(81)
|
|
QEvent__ContextMenu = QEvent__Type(82)
|
|
QEvent__InputMethod = QEvent__Type(83)
|
|
QEvent__TabletMove = QEvent__Type(87)
|
|
QEvent__LocaleChange = QEvent__Type(88)
|
|
QEvent__LanguageChange = QEvent__Type(89)
|
|
QEvent__LayoutDirectionChange = QEvent__Type(90)
|
|
QEvent__Style = QEvent__Type(91)
|
|
QEvent__TabletPress = QEvent__Type(92)
|
|
QEvent__TabletRelease = QEvent__Type(93)
|
|
QEvent__OkRequest = QEvent__Type(94)
|
|
QEvent__HelpRequest = QEvent__Type(95)
|
|
QEvent__IconDrag = QEvent__Type(96)
|
|
QEvent__FontChange = QEvent__Type(97)
|
|
QEvent__EnabledChange = QEvent__Type(98)
|
|
QEvent__ActivationChange = QEvent__Type(99)
|
|
QEvent__StyleChange = QEvent__Type(100)
|
|
QEvent__IconTextChange = QEvent__Type(101)
|
|
QEvent__ModifiedChange = QEvent__Type(102)
|
|
QEvent__MouseTrackingChange = QEvent__Type(109)
|
|
QEvent__WindowBlocked = QEvent__Type(103)
|
|
QEvent__WindowUnblocked = QEvent__Type(104)
|
|
QEvent__WindowStateChange = QEvent__Type(105)
|
|
QEvent__ReadOnlyChange = QEvent__Type(106)
|
|
QEvent__ToolTip = QEvent__Type(110)
|
|
QEvent__WhatsThis = QEvent__Type(111)
|
|
QEvent__StatusTip = QEvent__Type(112)
|
|
QEvent__ActionChanged = QEvent__Type(113)
|
|
QEvent__ActionAdded = QEvent__Type(114)
|
|
QEvent__ActionRemoved = QEvent__Type(115)
|
|
QEvent__FileOpen = QEvent__Type(116)
|
|
QEvent__Shortcut = QEvent__Type(117)
|
|
QEvent__ShortcutOverride = QEvent__Type(51)
|
|
QEvent__WhatsThisClicked = QEvent__Type(118)
|
|
QEvent__ToolBarChange = QEvent__Type(120)
|
|
QEvent__ApplicationActivate = QEvent__Type(121)
|
|
QEvent__ApplicationActivated = QEvent__Type(QEvent__ApplicationActivate)
|
|
QEvent__ApplicationDeactivate = QEvent__Type(122)
|
|
QEvent__ApplicationDeactivated = QEvent__Type(QEvent__ApplicationDeactivate)
|
|
QEvent__QueryWhatsThis = QEvent__Type(123)
|
|
QEvent__EnterWhatsThisMode = QEvent__Type(124)
|
|
QEvent__LeaveWhatsThisMode = QEvent__Type(125)
|
|
QEvent__ZOrderChange = QEvent__Type(126)
|
|
QEvent__HoverEnter = QEvent__Type(127)
|
|
QEvent__HoverLeave = QEvent__Type(128)
|
|
QEvent__HoverMove = QEvent__Type(129)
|
|
QEvent__EnterEditFocus = QEvent__Type(150)
|
|
QEvent__LeaveEditFocus = QEvent__Type(151)
|
|
QEvent__AcceptDropsChange = QEvent__Type(152)
|
|
QEvent__ZeroTimerEvent = QEvent__Type(154)
|
|
QEvent__GraphicsSceneMouseMove = QEvent__Type(155)
|
|
QEvent__GraphicsSceneMousePress = QEvent__Type(156)
|
|
QEvent__GraphicsSceneMouseRelease = QEvent__Type(157)
|
|
QEvent__GraphicsSceneMouseDoubleClick = QEvent__Type(158)
|
|
QEvent__GraphicsSceneContextMenu = QEvent__Type(159)
|
|
QEvent__GraphicsSceneHoverEnter = QEvent__Type(160)
|
|
QEvent__GraphicsSceneHoverMove = QEvent__Type(161)
|
|
QEvent__GraphicsSceneHoverLeave = QEvent__Type(162)
|
|
QEvent__GraphicsSceneHelp = QEvent__Type(163)
|
|
QEvent__GraphicsSceneDragEnter = QEvent__Type(164)
|
|
QEvent__GraphicsSceneDragMove = QEvent__Type(165)
|
|
QEvent__GraphicsSceneDragLeave = QEvent__Type(166)
|
|
QEvent__GraphicsSceneDrop = QEvent__Type(167)
|
|
QEvent__GraphicsSceneWheel = QEvent__Type(168)
|
|
QEvent__KeyboardLayoutChange = QEvent__Type(169)
|
|
QEvent__DynamicPropertyChange = QEvent__Type(170)
|
|
QEvent__TabletEnterProximity = QEvent__Type(171)
|
|
QEvent__TabletLeaveProximity = QEvent__Type(172)
|
|
QEvent__NonClientAreaMouseMove = QEvent__Type(173)
|
|
QEvent__NonClientAreaMouseButtonPress = QEvent__Type(174)
|
|
QEvent__NonClientAreaMouseButtonRelease = QEvent__Type(175)
|
|
QEvent__NonClientAreaMouseButtonDblClick = QEvent__Type(176)
|
|
QEvent__MacSizeChange = QEvent__Type(177)
|
|
QEvent__ContentsRectChange = QEvent__Type(178)
|
|
QEvent__MacGLWindowChange = QEvent__Type(179)
|
|
QEvent__FutureCallOut = QEvent__Type(180)
|
|
QEvent__GraphicsSceneResize = QEvent__Type(181)
|
|
QEvent__GraphicsSceneMove = QEvent__Type(182)
|
|
QEvent__CursorChange = QEvent__Type(183)
|
|
QEvent__ToolTipChange = QEvent__Type(184)
|
|
QEvent__NetworkReplyUpdated = QEvent__Type(185)
|
|
QEvent__GrabMouse = QEvent__Type(186)
|
|
QEvent__UngrabMouse = QEvent__Type(187)
|
|
QEvent__GrabKeyboard = QEvent__Type(188)
|
|
QEvent__UngrabKeyboard = QEvent__Type(189)
|
|
QEvent__MacGLClearDrawable = QEvent__Type(191)
|
|
QEvent__StateMachineSignal = QEvent__Type(192)
|
|
QEvent__StateMachineWrapped = QEvent__Type(193)
|
|
QEvent__TouchBegin = QEvent__Type(194)
|
|
QEvent__TouchUpdate = QEvent__Type(195)
|
|
QEvent__TouchEnd = QEvent__Type(196)
|
|
QEvent__NativeGesture = QEvent__Type(197)
|
|
QEvent__RequestSoftwareInputPanel = QEvent__Type(199)
|
|
QEvent__CloseSoftwareInputPanel = QEvent__Type(200)
|
|
QEvent__WinIdChange = QEvent__Type(203)
|
|
QEvent__Gesture = QEvent__Type(198)
|
|
QEvent__GestureOverride = QEvent__Type(202)
|
|
QEvent__ScrollPrepare = QEvent__Type(204)
|
|
QEvent__Scroll = QEvent__Type(205)
|
|
QEvent__Expose = QEvent__Type(206)
|
|
QEvent__InputMethodQuery = QEvent__Type(207)
|
|
QEvent__OrientationChange = QEvent__Type(208)
|
|
QEvent__TouchCancel = QEvent__Type(209)
|
|
QEvent__ThemeChange = QEvent__Type(210)
|
|
QEvent__SockClose = QEvent__Type(211)
|
|
QEvent__PlatformPanel = QEvent__Type(212)
|
|
QEvent__StyleAnimationUpdate = QEvent__Type(213)
|
|
QEvent__ApplicationStateChange = QEvent__Type(214)
|
|
QEvent__WindowChangeInternal = QEvent__Type(215)
|
|
QEvent__ScreenChangeInternal = QEvent__Type(216)
|
|
QEvent__PlatformSurface = QEvent__Type(217)
|
|
QEvent__User = QEvent__Type(1000)
|
|
QEvent__MaxUser = QEvent__Type(65535)
|
|
)
|
|
|
|
type QEvent struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QEvent_ITF interface {
|
|
QEvent_PTR() *QEvent
|
|
}
|
|
|
|
func (p *QEvent) QEvent_PTR() *QEvent {
|
|
return p
|
|
}
|
|
|
|
func (p *QEvent) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QEvent) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQEvent(ptr QEvent_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QEvent_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQEventFromPointer(ptr unsafe.Pointer) *QEvent {
|
|
var n = new(QEvent)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQEventFromPointer(ptr unsafe.Pointer) *QEvent {
|
|
var n = NewQEventFromPointer(ptr)
|
|
for len(n.ObjectNameAbs()) < len("QEvent_") {
|
|
n.SetObjectNameAbs("QEvent_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQEvent(ty QEvent__Type) *QEvent {
|
|
defer qt.Recovering("QEvent::QEvent")
|
|
|
|
return newQEventFromPointer(C.QEvent_NewQEvent(C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QEvent) Accept() {
|
|
defer qt.Recovering("QEvent::accept")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEvent_Accept(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QEvent) Ignore() {
|
|
defer qt.Recovering("QEvent::ignore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEvent_Ignore(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QEvent) IsAccepted() bool {
|
|
defer qt.Recovering("QEvent::isAccepted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEvent_IsAccepted(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QEvent_RegisterEventType(hint int) int {
|
|
defer qt.Recovering("QEvent::registerEventType")
|
|
|
|
return int(C.QEvent_QEvent_RegisterEventType(C.int(hint)))
|
|
}
|
|
|
|
func (ptr *QEvent) RegisterEventType(hint int) int {
|
|
defer qt.Recovering("QEvent::registerEventType")
|
|
|
|
return int(C.QEvent_QEvent_RegisterEventType(C.int(hint)))
|
|
}
|
|
|
|
func (ptr *QEvent) SetAccepted(accepted bool) {
|
|
defer qt.Recovering("QEvent::setAccepted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEvent_SetAccepted(ptr.Pointer(), C.int(qt.GoBoolToInt(accepted)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEvent) Spontaneous() bool {
|
|
defer qt.Recovering("QEvent::spontaneous")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEvent_Spontaneous(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QEvent) Type() QEvent__Type {
|
|
defer qt.Recovering("QEvent::type")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QEvent__Type(C.QEvent_Type(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QEvent) DestroyQEvent() {
|
|
defer qt.Recovering("QEvent::~QEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectNameAbs())
|
|
C.QEvent_DestroyQEvent(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEvent) ObjectNameAbs() string {
|
|
defer qt.Recovering("QEvent::objectNameAbs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QEvent_ObjectNameAbs(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QEvent) SetObjectNameAbs(name string) {
|
|
defer qt.Recovering("QEvent::setObjectNameAbs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEvent_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
|
|
}
|
|
}
|
|
|
|
//QEventLoop::ProcessEventsFlag
|
|
type QEventLoop__ProcessEventsFlag int64
|
|
|
|
const (
|
|
QEventLoop__AllEvents = QEventLoop__ProcessEventsFlag(0x00)
|
|
QEventLoop__ExcludeUserInputEvents = QEventLoop__ProcessEventsFlag(0x01)
|
|
QEventLoop__ExcludeSocketNotifiers = QEventLoop__ProcessEventsFlag(0x02)
|
|
QEventLoop__WaitForMoreEvents = QEventLoop__ProcessEventsFlag(0x04)
|
|
QEventLoop__X11ExcludeTimers = QEventLoop__ProcessEventsFlag(0x08)
|
|
QEventLoop__EventLoopExec = QEventLoop__ProcessEventsFlag(0x20)
|
|
QEventLoop__DialogExec = QEventLoop__ProcessEventsFlag(0x40)
|
|
)
|
|
|
|
type QEventLoop struct {
|
|
QObject
|
|
}
|
|
|
|
type QEventLoop_ITF interface {
|
|
QObject_ITF
|
|
QEventLoop_PTR() *QEventLoop
|
|
}
|
|
|
|
func (p *QEventLoop) QEventLoop_PTR() *QEventLoop {
|
|
return p
|
|
}
|
|
|
|
func (p *QEventLoop) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QEventLoop) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQEventLoop(ptr QEventLoop_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QEventLoop_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQEventLoopFromPointer(ptr unsafe.Pointer) *QEventLoop {
|
|
var n = new(QEventLoop)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQEventLoopFromPointer(ptr unsafe.Pointer) *QEventLoop {
|
|
var n = NewQEventLoopFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QEventLoop_") {
|
|
n.SetObjectName("QEventLoop_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQEventLoop(parent QObject_ITF) *QEventLoop {
|
|
defer qt.Recovering("QEventLoop::QEventLoop")
|
|
|
|
return newQEventLoopFromPointer(C.QEventLoop_NewQEventLoop(PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQEventLoop_Event
|
|
func callbackQEventLoop_Event(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QEventLoop::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQEventLoopFromPointer(ptr).EventDefault(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QEventLoop) ConnectEvent(f func(event *QEvent) bool) {
|
|
defer qt.Recovering("connect QEventLoop::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QEventLoop::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) Event(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QEventLoop::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEventLoop_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QEventLoop) EventDefault(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QEventLoop::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEventLoop_EventDefault(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QEventLoop) Exec(flags QEventLoop__ProcessEventsFlag) int {
|
|
defer qt.Recovering("QEventLoop::exec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QEventLoop_Exec(ptr.Pointer(), C.int(flags)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QEventLoop) Exit(returnCode int) {
|
|
defer qt.Recovering("QEventLoop::exit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_Exit(ptr.Pointer(), C.int(returnCode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) IsRunning() bool {
|
|
defer qt.Recovering("QEventLoop::isRunning")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEventLoop_IsRunning(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QEventLoop) ProcessEvents(flags QEventLoop__ProcessEventsFlag) bool {
|
|
defer qt.Recovering("QEventLoop::processEvents")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEventLoop_ProcessEvents(ptr.Pointer(), C.int(flags)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QEventLoop) ProcessEvents2(flags QEventLoop__ProcessEventsFlag, maxTime int) {
|
|
defer qt.Recovering("QEventLoop::processEvents")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_ProcessEvents2(ptr.Pointer(), C.int(flags), C.int(maxTime))
|
|
}
|
|
}
|
|
|
|
//export callbackQEventLoop_Quit
|
|
func callbackQEventLoop_Quit(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QEventLoop::quit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "quit"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QEventLoop) ConnectQuit(f func()) {
|
|
defer qt.Recovering("connect QEventLoop::quit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "quit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DisconnectQuit() {
|
|
defer qt.Recovering("disconnect QEventLoop::quit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "quit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) Quit() {
|
|
defer qt.Recovering("QEventLoop::quit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_Quit(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) WakeUp() {
|
|
defer qt.Recovering("QEventLoop::wakeUp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_WakeUp(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DestroyQEventLoop() {
|
|
defer qt.Recovering("QEventLoop::~QEventLoop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QEventLoop_DestroyQEventLoop(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQEventLoop_TimerEvent
|
|
func callbackQEventLoop_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QEventLoop::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQEventLoopFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QEventLoop::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QEventLoop::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QEventLoop::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QEventLoop::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQEventLoop_ChildEvent
|
|
func callbackQEventLoop_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QEventLoop::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQEventLoopFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QEventLoop::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QEventLoop::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QEventLoop::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QEventLoop::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQEventLoop_ConnectNotify
|
|
func callbackQEventLoop_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QEventLoop::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQEventLoopFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QEventLoop::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QEventLoop::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QEventLoop::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QEventLoop::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQEventLoop_CustomEvent
|
|
func callbackQEventLoop_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QEventLoop::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQEventLoopFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QEventLoop::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QEventLoop::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QEventLoop::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QEventLoop::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQEventLoop_DeleteLater
|
|
func callbackQEventLoop_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QEventLoop::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQEventLoopFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QEventLoop::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QEventLoop::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DeleteLater() {
|
|
defer qt.Recovering("QEventLoop::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QEventLoop_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DeleteLaterDefault() {
|
|
defer qt.Recovering("QEventLoop::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QEventLoop_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQEventLoop_DisconnectNotify
|
|
func callbackQEventLoop_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QEventLoop::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQEventLoopFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QEventLoop::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QEventLoop::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QEventLoop::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QEventLoop::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoop_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQEventLoop_EventFilter
|
|
func callbackQEventLoop_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QEventLoop::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQEventLoopFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QEventLoop) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QEventLoop::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QEventLoop::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QEventLoop::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEventLoop_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QEventLoop) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QEventLoop::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEventLoop_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQEventLoop_MetaObject
|
|
func callbackQEventLoop_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QEventLoop::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQEventLoopFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QEventLoop) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QEventLoop::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QEventLoop::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventLoop) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QEventLoop::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QEventLoop_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QEventLoop) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QEventLoop::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QEventLoop_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QEventLoopLocker struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QEventLoopLocker_ITF interface {
|
|
QEventLoopLocker_PTR() *QEventLoopLocker
|
|
}
|
|
|
|
func (p *QEventLoopLocker) QEventLoopLocker_PTR() *QEventLoopLocker {
|
|
return p
|
|
}
|
|
|
|
func (p *QEventLoopLocker) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QEventLoopLocker) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQEventLoopLocker(ptr QEventLoopLocker_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QEventLoopLocker_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQEventLoopLockerFromPointer(ptr unsafe.Pointer) *QEventLoopLocker {
|
|
var n = new(QEventLoopLocker)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQEventLoopLockerFromPointer(ptr unsafe.Pointer) *QEventLoopLocker {
|
|
var n = NewQEventLoopLockerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQEventLoopLocker() *QEventLoopLocker {
|
|
defer qt.Recovering("QEventLoopLocker::QEventLoopLocker")
|
|
|
|
return newQEventLoopLockerFromPointer(C.QEventLoopLocker_NewQEventLoopLocker())
|
|
}
|
|
|
|
func NewQEventLoopLocker2(loop QEventLoop_ITF) *QEventLoopLocker {
|
|
defer qt.Recovering("QEventLoopLocker::QEventLoopLocker")
|
|
|
|
return newQEventLoopLockerFromPointer(C.QEventLoopLocker_NewQEventLoopLocker2(PointerFromQEventLoop(loop)))
|
|
}
|
|
|
|
func NewQEventLoopLocker3(thread QThread_ITF) *QEventLoopLocker {
|
|
defer qt.Recovering("QEventLoopLocker::QEventLoopLocker")
|
|
|
|
return newQEventLoopLockerFromPointer(C.QEventLoopLocker_NewQEventLoopLocker3(PointerFromQThread(thread)))
|
|
}
|
|
|
|
func (ptr *QEventLoopLocker) DestroyQEventLoopLocker() {
|
|
defer qt.Recovering("QEventLoopLocker::~QEventLoopLocker")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventLoopLocker_DestroyQEventLoopLocker(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QEventTransition struct {
|
|
QAbstractTransition
|
|
}
|
|
|
|
type QEventTransition_ITF interface {
|
|
QAbstractTransition_ITF
|
|
QEventTransition_PTR() *QEventTransition
|
|
}
|
|
|
|
func (p *QEventTransition) QEventTransition_PTR() *QEventTransition {
|
|
return p
|
|
}
|
|
|
|
func (p *QEventTransition) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractTransition_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QEventTransition) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractTransition_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQEventTransition(ptr QEventTransition_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QEventTransition_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQEventTransitionFromPointer(ptr unsafe.Pointer) *QEventTransition {
|
|
var n = new(QEventTransition)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQEventTransitionFromPointer(ptr unsafe.Pointer) *QEventTransition {
|
|
var n = NewQEventTransitionFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QEventTransition_") {
|
|
n.SetObjectName("QEventTransition_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQEventTransition2(object QObject_ITF, ty QEvent__Type, sourceState QState_ITF) *QEventTransition {
|
|
defer qt.Recovering("QEventTransition::QEventTransition")
|
|
|
|
return newQEventTransitionFromPointer(C.QEventTransition_NewQEventTransition2(PointerFromQObject(object), C.int(ty), PointerFromQState(sourceState)))
|
|
}
|
|
|
|
func NewQEventTransition(sourceState QState_ITF) *QEventTransition {
|
|
defer qt.Recovering("QEventTransition::QEventTransition")
|
|
|
|
return newQEventTransitionFromPointer(C.QEventTransition_NewQEventTransition(PointerFromQState(sourceState)))
|
|
}
|
|
|
|
//export callbackQEventTransition_Event
|
|
func callbackQEventTransition_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QEventTransition::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQEventTransitionFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QEventTransition::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QEventTransition::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QEventTransition::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEventTransition_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QEventTransition) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QEventTransition::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEventTransition_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QEventTransition) EventSource() *QObject {
|
|
defer qt.Recovering("QEventTransition::eventSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QEventTransition_EventSource(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQEventTransition_EventTest
|
|
func callbackQEventTransition_EventTest(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QEventTransition::eventTest")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventTest"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQEventTransitionFromPointer(ptr).EventTestDefault(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectEventTest(f func(event *QEvent) bool) {
|
|
defer qt.Recovering("connect QEventTransition::eventTest")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventTest", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectEventTest() {
|
|
defer qt.Recovering("disconnect QEventTransition::eventTest")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventTest")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) EventTest(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QEventTransition::eventTest")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEventTransition_EventTest(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QEventTransition) EventTestDefault(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QEventTransition::eventTest")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEventTransition_EventTestDefault(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QEventTransition) EventType() QEvent__Type {
|
|
defer qt.Recovering("QEventTransition::eventType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QEvent__Type(C.QEventTransition_EventType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQEventTransition_OnTransition
|
|
func callbackQEventTransition_OnTransition(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QEventTransition::onTransition")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onTransition"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQEventTransitionFromPointer(ptr).OnTransitionDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectOnTransition(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QEventTransition::onTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onTransition", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectOnTransition() {
|
|
defer qt.Recovering("disconnect QEventTransition::onTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onTransition")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) OnTransition(event QEvent_ITF) {
|
|
defer qt.Recovering("QEventTransition::onTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_OnTransition(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) OnTransitionDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QEventTransition::onTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_OnTransitionDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) SetEventSource(object QObject_ITF) {
|
|
defer qt.Recovering("QEventTransition::setEventSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_SetEventSource(ptr.Pointer(), PointerFromQObject(object))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) SetEventType(ty QEvent__Type) {
|
|
defer qt.Recovering("QEventTransition::setEventType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_SetEventType(ptr.Pointer(), C.int(ty))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DestroyQEventTransition() {
|
|
defer qt.Recovering("QEventTransition::~QEventTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QEventTransition_DestroyQEventTransition(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQEventTransition_TimerEvent
|
|
func callbackQEventTransition_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QEventTransition::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQEventTransitionFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QEventTransition::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QEventTransition::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QEventTransition::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QEventTransition::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQEventTransition_ChildEvent
|
|
func callbackQEventTransition_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QEventTransition::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQEventTransitionFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QEventTransition::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QEventTransition::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QEventTransition::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QEventTransition::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQEventTransition_ConnectNotify
|
|
func callbackQEventTransition_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QEventTransition::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQEventTransitionFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QEventTransition::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QEventTransition::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QEventTransition::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QEventTransition::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQEventTransition_CustomEvent
|
|
func callbackQEventTransition_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QEventTransition::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQEventTransitionFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QEventTransition::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QEventTransition::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QEventTransition::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QEventTransition::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQEventTransition_DeleteLater
|
|
func callbackQEventTransition_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QEventTransition::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQEventTransitionFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QEventTransition::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QEventTransition::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DeleteLater() {
|
|
defer qt.Recovering("QEventTransition::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QEventTransition_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DeleteLaterDefault() {
|
|
defer qt.Recovering("QEventTransition::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QEventTransition_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQEventTransition_DisconnectNotify
|
|
func callbackQEventTransition_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QEventTransition::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQEventTransitionFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QEventTransition::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QEventTransition::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QEventTransition::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QEventTransition::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QEventTransition_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQEventTransition_EventFilter
|
|
func callbackQEventTransition_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QEventTransition::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQEventTransitionFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QEventTransition::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QEventTransition::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QEventTransition::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEventTransition_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QEventTransition) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QEventTransition::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QEventTransition_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQEventTransition_MetaObject
|
|
func callbackQEventTransition_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QEventTransition::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQEventTransitionFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QEventTransition) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QEventTransition::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QEventTransition::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QEventTransition) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QEventTransition::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QEventTransition_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QEventTransition) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QEventTransition::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QEventTransition_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QException struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QException_ITF interface {
|
|
QException_PTR() *QException
|
|
}
|
|
|
|
func (p *QException) QException_PTR() *QException {
|
|
return p
|
|
}
|
|
|
|
func (p *QException) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QException) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQException(ptr QException_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QException_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQExceptionFromPointer(ptr unsafe.Pointer) *QException {
|
|
var n = new(QException)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQExceptionFromPointer(ptr unsafe.Pointer) *QException {
|
|
var n = NewQExceptionFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QExplicitlySharedDataPointer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QExplicitlySharedDataPointer_ITF interface {
|
|
QExplicitlySharedDataPointer_PTR() *QExplicitlySharedDataPointer
|
|
}
|
|
|
|
func (p *QExplicitlySharedDataPointer) QExplicitlySharedDataPointer_PTR() *QExplicitlySharedDataPointer {
|
|
return p
|
|
}
|
|
|
|
func (p *QExplicitlySharedDataPointer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QExplicitlySharedDataPointer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQExplicitlySharedDataPointer(ptr QExplicitlySharedDataPointer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QExplicitlySharedDataPointer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQExplicitlySharedDataPointerFromPointer(ptr unsafe.Pointer) *QExplicitlySharedDataPointer {
|
|
var n = new(QExplicitlySharedDataPointer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQExplicitlySharedDataPointerFromPointer(ptr unsafe.Pointer) *QExplicitlySharedDataPointer {
|
|
var n = NewQExplicitlySharedDataPointerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QFile struct {
|
|
QFileDevice
|
|
}
|
|
|
|
type QFile_ITF interface {
|
|
QFileDevice_ITF
|
|
QFile_PTR() *QFile
|
|
}
|
|
|
|
func (p *QFile) QFile_PTR() *QFile {
|
|
return p
|
|
}
|
|
|
|
func (p *QFile) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QFileDevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QFile) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QFileDevice_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQFile(ptr QFile_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFile_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQFileFromPointer(ptr unsafe.Pointer) *QFile {
|
|
var n = new(QFile)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQFileFromPointer(ptr unsafe.Pointer) *QFile {
|
|
var n = NewQFileFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QFile_") {
|
|
n.SetObjectName("QFile_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQFile3(parent QObject_ITF) *QFile {
|
|
defer qt.Recovering("QFile::QFile")
|
|
|
|
return newQFileFromPointer(C.QFile_NewQFile3(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQFile(name string) *QFile {
|
|
defer qt.Recovering("QFile::QFile")
|
|
|
|
return newQFileFromPointer(C.QFile_NewQFile(C.CString(name)))
|
|
}
|
|
|
|
func NewQFile4(name string, parent QObject_ITF) *QFile {
|
|
defer qt.Recovering("QFile::QFile")
|
|
|
|
return newQFileFromPointer(C.QFile_NewQFile4(C.CString(name), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func QFile_Copy2(fileName string, newName string) bool {
|
|
defer qt.Recovering("QFile::copy")
|
|
|
|
return C.QFile_QFile_Copy2(C.CString(fileName), C.CString(newName)) != 0
|
|
}
|
|
|
|
func (ptr *QFile) Copy2(fileName string, newName string) bool {
|
|
defer qt.Recovering("QFile::copy")
|
|
|
|
return C.QFile_QFile_Copy2(C.CString(fileName), C.CString(newName)) != 0
|
|
}
|
|
|
|
func (ptr *QFile) Copy(newName string) bool {
|
|
defer qt.Recovering("QFile::copy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_Copy(ptr.Pointer(), C.CString(newName)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QFile_DecodeName(localFileName string) string {
|
|
defer qt.Recovering("QFile::decodeName")
|
|
|
|
return C.GoString(C.QFile_QFile_DecodeName(C.CString(localFileName)))
|
|
}
|
|
|
|
func (ptr *QFile) DecodeName(localFileName string) string {
|
|
defer qt.Recovering("QFile::decodeName")
|
|
|
|
return C.GoString(C.QFile_QFile_DecodeName(C.CString(localFileName)))
|
|
}
|
|
|
|
func QFile_DecodeName2(localFileName string) string {
|
|
defer qt.Recovering("QFile::decodeName")
|
|
|
|
return C.GoString(C.QFile_QFile_DecodeName2(C.CString(localFileName)))
|
|
}
|
|
|
|
func (ptr *QFile) DecodeName2(localFileName string) string {
|
|
defer qt.Recovering("QFile::decodeName")
|
|
|
|
return C.GoString(C.QFile_QFile_DecodeName2(C.CString(localFileName)))
|
|
}
|
|
|
|
func QFile_EncodeName(fileName string) string {
|
|
defer qt.Recovering("QFile::encodeName")
|
|
|
|
return C.GoString(C.QFile_QFile_EncodeName(C.CString(fileName)))
|
|
}
|
|
|
|
func (ptr *QFile) EncodeName(fileName string) string {
|
|
defer qt.Recovering("QFile::encodeName")
|
|
|
|
return C.GoString(C.QFile_QFile_EncodeName(C.CString(fileName)))
|
|
}
|
|
|
|
func QFile_Exists(fileName string) bool {
|
|
defer qt.Recovering("QFile::exists")
|
|
|
|
return C.QFile_QFile_Exists(C.CString(fileName)) != 0
|
|
}
|
|
|
|
func (ptr *QFile) Exists(fileName string) bool {
|
|
defer qt.Recovering("QFile::exists")
|
|
|
|
return C.QFile_QFile_Exists(C.CString(fileName)) != 0
|
|
}
|
|
|
|
func (ptr *QFile) Exists2() bool {
|
|
defer qt.Recovering("QFile::exists")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_Exists2(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFile_FileName
|
|
func callbackQFile_FileName(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QFile::fileName")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "fileName"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString(NewQFileFromPointer(ptr).FileNameDefault())
|
|
}
|
|
|
|
func (ptr *QFile) ConnectFileName(f func() string) {
|
|
defer qt.Recovering("connect QFile::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "fileName", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectFileName() {
|
|
defer qt.Recovering("disconnect QFile::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "fileName")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) FileName() string {
|
|
defer qt.Recovering("QFile::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFile_FileName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFile) FileNameDefault() string {
|
|
defer qt.Recovering("QFile::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFile_FileNameDefault(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func QFile_Link2(fileName string, linkName string) bool {
|
|
defer qt.Recovering("QFile::link")
|
|
|
|
return C.QFile_QFile_Link2(C.CString(fileName), C.CString(linkName)) != 0
|
|
}
|
|
|
|
func (ptr *QFile) Link2(fileName string, linkName string) bool {
|
|
defer qt.Recovering("QFile::link")
|
|
|
|
return C.QFile_QFile_Link2(C.CString(fileName), C.CString(linkName)) != 0
|
|
}
|
|
|
|
func (ptr *QFile) Link(linkName string) bool {
|
|
defer qt.Recovering("QFile::link")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_Link(ptr.Pointer(), C.CString(linkName)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFile_Open
|
|
func callbackQFile_Open(ptr unsafe.Pointer, ptrName *C.char, mode C.int) C.int {
|
|
defer qt.Recovering("callback QFile::open")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "open"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(QIODevice__OpenModeFlag) bool)(QIODevice__OpenModeFlag(mode))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileFromPointer(ptr).OpenDefault(QIODevice__OpenModeFlag(mode))))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectOpen(f func(mode QIODevice__OpenModeFlag) bool) {
|
|
defer qt.Recovering("connect QFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "open", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectOpen() {
|
|
defer qt.Recovering("disconnect QFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "open")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) Open(mode QIODevice__OpenModeFlag) bool {
|
|
defer qt.Recovering("QFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_Open(ptr.Pointer(), C.int(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) OpenDefault(mode QIODevice__OpenModeFlag) bool {
|
|
defer qt.Recovering("QFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_OpenDefault(ptr.Pointer(), C.int(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) Open3(fd int, mode QIODevice__OpenModeFlag, handleFlags QFileDevice__FileHandleFlag) bool {
|
|
defer qt.Recovering("QFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_Open3(ptr.Pointer(), C.int(fd), C.int(mode), C.int(handleFlags)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QFile_Permissions2(fileName string) QFileDevice__Permission {
|
|
defer qt.Recovering("QFile::permissions")
|
|
|
|
return QFileDevice__Permission(C.QFile_QFile_Permissions2(C.CString(fileName)))
|
|
}
|
|
|
|
func (ptr *QFile) Permissions2(fileName string) QFileDevice__Permission {
|
|
defer qt.Recovering("QFile::permissions")
|
|
|
|
return QFileDevice__Permission(C.QFile_QFile_Permissions2(C.CString(fileName)))
|
|
}
|
|
|
|
//export callbackQFile_Permissions
|
|
func callbackQFile_Permissions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QFile::permissions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "permissions"); signal != nil {
|
|
return C.int(signal.(func() QFileDevice__Permission)())
|
|
}
|
|
|
|
return C.int(NewQFileFromPointer(ptr).PermissionsDefault())
|
|
}
|
|
|
|
func (ptr *QFile) ConnectPermissions(f func() QFileDevice__Permission) {
|
|
defer qt.Recovering("connect QFile::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "permissions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectPermissions() {
|
|
defer qt.Recovering("disconnect QFile::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "permissions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) Permissions() QFileDevice__Permission {
|
|
defer qt.Recovering("QFile::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QFileDevice__Permission(C.QFile_Permissions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFile) PermissionsDefault() QFileDevice__Permission {
|
|
defer qt.Recovering("QFile::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QFileDevice__Permission(C.QFile_PermissionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFile) Remove() bool {
|
|
defer qt.Recovering("QFile::remove")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_Remove(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QFile_Remove2(fileName string) bool {
|
|
defer qt.Recovering("QFile::remove")
|
|
|
|
return C.QFile_QFile_Remove2(C.CString(fileName)) != 0
|
|
}
|
|
|
|
func (ptr *QFile) Remove2(fileName string) bool {
|
|
defer qt.Recovering("QFile::remove")
|
|
|
|
return C.QFile_QFile_Remove2(C.CString(fileName)) != 0
|
|
}
|
|
|
|
func (ptr *QFile) Rename(newName string) bool {
|
|
defer qt.Recovering("QFile::rename")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_Rename(ptr.Pointer(), C.CString(newName)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QFile_Rename2(oldName string, newName string) bool {
|
|
defer qt.Recovering("QFile::rename")
|
|
|
|
return C.QFile_QFile_Rename2(C.CString(oldName), C.CString(newName)) != 0
|
|
}
|
|
|
|
func (ptr *QFile) Rename2(oldName string, newName string) bool {
|
|
defer qt.Recovering("QFile::rename")
|
|
|
|
return C.QFile_QFile_Rename2(C.CString(oldName), C.CString(newName)) != 0
|
|
}
|
|
|
|
func QFile_Resize2(fileName string, sz int64) bool {
|
|
defer qt.Recovering("QFile::resize")
|
|
|
|
return C.QFile_QFile_Resize2(C.CString(fileName), C.longlong(sz)) != 0
|
|
}
|
|
|
|
func (ptr *QFile) Resize2(fileName string, sz int64) bool {
|
|
defer qt.Recovering("QFile::resize")
|
|
|
|
return C.QFile_QFile_Resize2(C.CString(fileName), C.longlong(sz)) != 0
|
|
}
|
|
|
|
//export callbackQFile_Resize
|
|
func callbackQFile_Resize(ptr unsafe.Pointer, ptrName *C.char, sz C.longlong) C.int {
|
|
defer qt.Recovering("callback QFile::resize")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resize"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int64) bool)(int64(sz))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileFromPointer(ptr).ResizeDefault(int64(sz))))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectResize(f func(sz int64) bool) {
|
|
defer qt.Recovering("connect QFile::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resize", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectResize() {
|
|
defer qt.Recovering("disconnect QFile::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resize")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) Resize(sz int64) bool {
|
|
defer qt.Recovering("QFile::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_Resize(ptr.Pointer(), C.longlong(sz)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) ResizeDefault(sz int64) bool {
|
|
defer qt.Recovering("QFile::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_ResizeDefault(ptr.Pointer(), C.longlong(sz)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) SetFileName(name string) {
|
|
defer qt.Recovering("QFile::setFileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_SetFileName(ptr.Pointer(), C.CString(name))
|
|
}
|
|
}
|
|
|
|
//export callbackQFile_SetPermissions
|
|
func callbackQFile_SetPermissions(ptr unsafe.Pointer, ptrName *C.char, permissions C.int) C.int {
|
|
defer qt.Recovering("callback QFile::setPermissions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setPermissions"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(QFileDevice__Permission) bool)(QFileDevice__Permission(permissions))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileFromPointer(ptr).SetPermissionsDefault(QFileDevice__Permission(permissions))))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectSetPermissions(f func(permissions QFileDevice__Permission) bool) {
|
|
defer qt.Recovering("connect QFile::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setPermissions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectSetPermissions() {
|
|
defer qt.Recovering("disconnect QFile::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setPermissions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) SetPermissions(permissions QFileDevice__Permission) bool {
|
|
defer qt.Recovering("QFile::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_SetPermissions(ptr.Pointer(), C.int(permissions)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) SetPermissionsDefault(permissions QFileDevice__Permission) bool {
|
|
defer qt.Recovering("QFile::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_SetPermissionsDefault(ptr.Pointer(), C.int(permissions)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QFile_SetPermissions2(fileName string, permissions QFileDevice__Permission) bool {
|
|
defer qt.Recovering("QFile::setPermissions")
|
|
|
|
return C.QFile_QFile_SetPermissions2(C.CString(fileName), C.int(permissions)) != 0
|
|
}
|
|
|
|
func (ptr *QFile) SetPermissions2(fileName string, permissions QFileDevice__Permission) bool {
|
|
defer qt.Recovering("QFile::setPermissions")
|
|
|
|
return C.QFile_QFile_SetPermissions2(C.CString(fileName), C.int(permissions)) != 0
|
|
}
|
|
|
|
//export callbackQFile_Size
|
|
func callbackQFile_Size(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QFile::size")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "size"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQFileFromPointer(ptr).SizeDefault())
|
|
}
|
|
|
|
func (ptr *QFile) ConnectSize(f func() int64) {
|
|
defer qt.Recovering("connect QFile::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "size", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectSize() {
|
|
defer qt.Recovering("disconnect QFile::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "size")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) Size() int64 {
|
|
defer qt.Recovering("QFile::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFile_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFile) SizeDefault() int64 {
|
|
defer qt.Recovering("QFile::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFile_SizeDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QFile_SymLinkTarget(fileName string) string {
|
|
defer qt.Recovering("QFile::symLinkTarget")
|
|
|
|
return C.GoString(C.QFile_QFile_SymLinkTarget(C.CString(fileName)))
|
|
}
|
|
|
|
func (ptr *QFile) SymLinkTarget(fileName string) string {
|
|
defer qt.Recovering("QFile::symLinkTarget")
|
|
|
|
return C.GoString(C.QFile_QFile_SymLinkTarget(C.CString(fileName)))
|
|
}
|
|
|
|
func (ptr *QFile) SymLinkTarget2() string {
|
|
defer qt.Recovering("QFile::symLinkTarget")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFile_SymLinkTarget2(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFile) DestroyQFile() {
|
|
defer qt.Recovering("QFile::~QFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QFile_DestroyQFile(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQFile_Seek
|
|
func callbackQFile_Seek(ptr unsafe.Pointer, ptrName *C.char, pos C.longlong) C.int {
|
|
defer qt.Recovering("callback QFile::seek")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "seek"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int64) bool)(int64(pos))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileFromPointer(ptr).SeekDefault(int64(pos))))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectSeek(f func(pos int64) bool) {
|
|
defer qt.Recovering("connect QFile::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "seek", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectSeek() {
|
|
defer qt.Recovering("disconnect QFile::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "seek")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) Seek(pos int64) bool {
|
|
defer qt.Recovering("QFile::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_Seek(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) SeekDefault(pos int64) bool {
|
|
defer qt.Recovering("QFile::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_SeekDefault(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFile_AtEnd
|
|
func callbackQFile_AtEnd(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QFile::atEnd")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "atEnd"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileFromPointer(ptr).AtEndDefault()))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectAtEnd(f func() bool) {
|
|
defer qt.Recovering("connect QFile::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "atEnd", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectAtEnd() {
|
|
defer qt.Recovering("disconnect QFile::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "atEnd")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) AtEnd() bool {
|
|
defer qt.Recovering("QFile::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_AtEnd(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) AtEndDefault() bool {
|
|
defer qt.Recovering("QFile::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_AtEndDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFile_Close
|
|
func callbackQFile_Close(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QFile::close")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQFileFromPointer(ptr).CloseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) ConnectClose(f func()) {
|
|
defer qt.Recovering("connect QFile::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "close", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectClose() {
|
|
defer qt.Recovering("disconnect QFile::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "close")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) Close() {
|
|
defer qt.Recovering("QFile::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_Close(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) CloseDefault() {
|
|
defer qt.Recovering("QFile::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_CloseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQFile_IsSequential
|
|
func callbackQFile_IsSequential(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QFile::isSequential")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "isSequential"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileFromPointer(ptr).IsSequentialDefault()))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectIsSequential(f func() bool) {
|
|
defer qt.Recovering("connect QFile::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "isSequential", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectIsSequential() {
|
|
defer qt.Recovering("disconnect QFile::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "isSequential")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) IsSequential() bool {
|
|
defer qt.Recovering("QFile::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_IsSequential(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) IsSequentialDefault() bool {
|
|
defer qt.Recovering("QFile::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_IsSequentialDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFile_Pos
|
|
func callbackQFile_Pos(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QFile::pos")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pos"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQFileFromPointer(ptr).PosDefault())
|
|
}
|
|
|
|
func (ptr *QFile) ConnectPos(f func() int64) {
|
|
defer qt.Recovering("connect QFile::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pos", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectPos() {
|
|
defer qt.Recovering("disconnect QFile::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pos")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) Pos() int64 {
|
|
defer qt.Recovering("QFile::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFile_Pos(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFile) PosDefault() int64 {
|
|
defer qt.Recovering("QFile::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFile_PosDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQFile_ReadLineData
|
|
func callbackQFile_ReadLineData(ptr unsafe.Pointer, ptrName *C.char, data *C.char, maxlen C.longlong) C.longlong {
|
|
defer qt.Recovering("callback QFile::readLineData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "readLineData"); signal != nil {
|
|
return C.longlong(signal.(func(string, int64) int64)(C.GoString(data), int64(maxlen)))
|
|
}
|
|
|
|
return C.longlong(NewQFileFromPointer(ptr).ReadLineDataDefault(C.GoString(data), int64(maxlen)))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectReadLineData(f func(data string, maxlen int64) int64) {
|
|
defer qt.Recovering("connect QFile::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "readLineData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectReadLineData() {
|
|
defer qt.Recovering("disconnect QFile::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "readLineData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) ReadLineData(data string, maxlen int64) int64 {
|
|
defer qt.Recovering("QFile::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFile_ReadLineData(ptr.Pointer(), C.CString(data), C.longlong(maxlen)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFile) ReadLineDataDefault(data string, maxlen int64) int64 {
|
|
defer qt.Recovering("QFile::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFile_ReadLineDataDefault(ptr.Pointer(), C.CString(data), C.longlong(maxlen)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQFile_WriteData
|
|
func callbackQFile_WriteData(ptr unsafe.Pointer, ptrName *C.char, data *C.char, len C.longlong) C.longlong {
|
|
defer qt.Recovering("callback QFile::writeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "writeData"); signal != nil {
|
|
return C.longlong(signal.(func(string, int64) int64)(C.GoString(data), int64(len)))
|
|
}
|
|
|
|
return C.longlong(NewQFileFromPointer(ptr).WriteDataDefault(C.GoString(data), int64(len)))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectWriteData(f func(data string, len int64) int64) {
|
|
defer qt.Recovering("connect QFile::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "writeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectWriteData() {
|
|
defer qt.Recovering("disconnect QFile::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "writeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) WriteData(data string, len int64) int64 {
|
|
defer qt.Recovering("QFile::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFile_WriteData(ptr.Pointer(), C.CString(data), C.longlong(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFile) WriteDataDefault(data string, len int64) int64 {
|
|
defer qt.Recovering("QFile::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFile_WriteDataDefault(ptr.Pointer(), C.CString(data), C.longlong(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQFile_BytesAvailable
|
|
func callbackQFile_BytesAvailable(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QFile::bytesAvailable")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesAvailable"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQFileFromPointer(ptr).BytesAvailableDefault())
|
|
}
|
|
|
|
func (ptr *QFile) ConnectBytesAvailable(f func() int64) {
|
|
defer qt.Recovering("connect QFile::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesAvailable", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectBytesAvailable() {
|
|
defer qt.Recovering("disconnect QFile::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) BytesAvailable() int64 {
|
|
defer qt.Recovering("QFile::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFile_BytesAvailable(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFile) BytesAvailableDefault() int64 {
|
|
defer qt.Recovering("QFile::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFile_BytesAvailableDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQFile_BytesToWrite
|
|
func callbackQFile_BytesToWrite(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QFile::bytesToWrite")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesToWrite"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQFileFromPointer(ptr).BytesToWriteDefault())
|
|
}
|
|
|
|
func (ptr *QFile) ConnectBytesToWrite(f func() int64) {
|
|
defer qt.Recovering("connect QFile::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesToWrite", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectBytesToWrite() {
|
|
defer qt.Recovering("disconnect QFile::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesToWrite")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) BytesToWrite() int64 {
|
|
defer qt.Recovering("QFile::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFile_BytesToWrite(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFile) BytesToWriteDefault() int64 {
|
|
defer qt.Recovering("QFile::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFile_BytesToWriteDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQFile_CanReadLine
|
|
func callbackQFile_CanReadLine(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QFile::canReadLine")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canReadLine"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileFromPointer(ptr).CanReadLineDefault()))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectCanReadLine(f func() bool) {
|
|
defer qt.Recovering("connect QFile::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canReadLine", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectCanReadLine() {
|
|
defer qt.Recovering("disconnect QFile::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canReadLine")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) CanReadLine() bool {
|
|
defer qt.Recovering("QFile::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_CanReadLine(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) CanReadLineDefault() bool {
|
|
defer qt.Recovering("QFile::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_CanReadLineDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFile_Reset
|
|
func callbackQFile_Reset(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QFile::reset")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "reset"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileFromPointer(ptr).ResetDefault()))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectReset(f func() bool) {
|
|
defer qt.Recovering("connect QFile::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "reset", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectReset() {
|
|
defer qt.Recovering("disconnect QFile::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "reset")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) Reset() bool {
|
|
defer qt.Recovering("QFile::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_Reset(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) ResetDefault() bool {
|
|
defer qt.Recovering("QFile::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_ResetDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFile_WaitForBytesWritten
|
|
func callbackQFile_WaitForBytesWritten(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) C.int {
|
|
defer qt.Recovering("callback QFile::waitForBytesWritten")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "waitForBytesWritten"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(msecs))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileFromPointer(ptr).WaitForBytesWrittenDefault(int(msecs))))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectWaitForBytesWritten(f func(msecs int) bool) {
|
|
defer qt.Recovering("connect QFile::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "waitForBytesWritten", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectWaitForBytesWritten() {
|
|
defer qt.Recovering("disconnect QFile::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "waitForBytesWritten")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) WaitForBytesWritten(msecs int) bool {
|
|
defer qt.Recovering("QFile::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_WaitForBytesWritten(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) WaitForBytesWrittenDefault(msecs int) bool {
|
|
defer qt.Recovering("QFile::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_WaitForBytesWrittenDefault(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFile_WaitForReadyRead
|
|
func callbackQFile_WaitForReadyRead(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) C.int {
|
|
defer qt.Recovering("callback QFile::waitForReadyRead")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "waitForReadyRead"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(msecs))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileFromPointer(ptr).WaitForReadyReadDefault(int(msecs))))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectWaitForReadyRead(f func(msecs int) bool) {
|
|
defer qt.Recovering("connect QFile::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "waitForReadyRead", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectWaitForReadyRead() {
|
|
defer qt.Recovering("disconnect QFile::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "waitForReadyRead")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) WaitForReadyRead(msecs int) bool {
|
|
defer qt.Recovering("QFile::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_WaitForReadyRead(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) WaitForReadyReadDefault(msecs int) bool {
|
|
defer qt.Recovering("QFile::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_WaitForReadyReadDefault(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFile_TimerEvent
|
|
func callbackQFile_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFile::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQFileFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QFile::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QFile::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QFile::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QFile::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFile_ChildEvent
|
|
func callbackQFile_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFile::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQFileFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QFile::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QFile::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QFile::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QFile::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFile_ConnectNotify
|
|
func callbackQFile_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFile::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQFileFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QFile::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QFile::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFile::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFile::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQFile_CustomEvent
|
|
func callbackQFile_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFile::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQFileFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QFile::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QFile::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QFile::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QFile::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFile_DeleteLater
|
|
func callbackQFile_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QFile::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQFileFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QFile::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QFile::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DeleteLater() {
|
|
defer qt.Recovering("QFile::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QFile_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DeleteLaterDefault() {
|
|
defer qt.Recovering("QFile::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QFile_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQFile_DisconnectNotify
|
|
func callbackQFile_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFile::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQFileFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QFile::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QFile::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFile::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFile::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFile_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQFile_Event
|
|
func callbackQFile_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QFile::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QFile::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QFile::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QFile::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QFile::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFile_EventFilter
|
|
func callbackQFile_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QFile::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QFile) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QFile::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QFile::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QFile::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFile) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QFile::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFile_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFile_MetaObject
|
|
func callbackQFile_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QFile::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQFileFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QFile) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QFile::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QFile::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFile) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QFile::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QFile_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QFile) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QFile::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QFile_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//QFileDevice::FileError
|
|
type QFileDevice__FileError int64
|
|
|
|
const (
|
|
QFileDevice__NoError = QFileDevice__FileError(0)
|
|
QFileDevice__ReadError = QFileDevice__FileError(1)
|
|
QFileDevice__WriteError = QFileDevice__FileError(2)
|
|
QFileDevice__FatalError = QFileDevice__FileError(3)
|
|
QFileDevice__ResourceError = QFileDevice__FileError(4)
|
|
QFileDevice__OpenError = QFileDevice__FileError(5)
|
|
QFileDevice__AbortError = QFileDevice__FileError(6)
|
|
QFileDevice__TimeOutError = QFileDevice__FileError(7)
|
|
QFileDevice__UnspecifiedError = QFileDevice__FileError(8)
|
|
QFileDevice__RemoveError = QFileDevice__FileError(9)
|
|
QFileDevice__RenameError = QFileDevice__FileError(10)
|
|
QFileDevice__PositionError = QFileDevice__FileError(11)
|
|
QFileDevice__ResizeError = QFileDevice__FileError(12)
|
|
QFileDevice__PermissionsError = QFileDevice__FileError(13)
|
|
QFileDevice__CopyError = QFileDevice__FileError(14)
|
|
)
|
|
|
|
//QFileDevice::FileHandleFlag
|
|
type QFileDevice__FileHandleFlag int64
|
|
|
|
const (
|
|
QFileDevice__AutoCloseHandle = QFileDevice__FileHandleFlag(0x0001)
|
|
QFileDevice__DontCloseHandle = QFileDevice__FileHandleFlag(0)
|
|
)
|
|
|
|
//QFileDevice::MemoryMapFlags
|
|
type QFileDevice__MemoryMapFlags int64
|
|
|
|
const (
|
|
QFileDevice__NoOptions = QFileDevice__MemoryMapFlags(0)
|
|
QFileDevice__MapPrivateOption = QFileDevice__MemoryMapFlags(0x0001)
|
|
)
|
|
|
|
//QFileDevice::Permission
|
|
type QFileDevice__Permission int64
|
|
|
|
const (
|
|
QFileDevice__ReadOwner = QFileDevice__Permission(0x4000)
|
|
QFileDevice__WriteOwner = QFileDevice__Permission(0x2000)
|
|
QFileDevice__ExeOwner = QFileDevice__Permission(0x1000)
|
|
QFileDevice__ReadUser = QFileDevice__Permission(0x0400)
|
|
QFileDevice__WriteUser = QFileDevice__Permission(0x0200)
|
|
QFileDevice__ExeUser = QFileDevice__Permission(0x0100)
|
|
QFileDevice__ReadGroup = QFileDevice__Permission(0x0040)
|
|
QFileDevice__WriteGroup = QFileDevice__Permission(0x0020)
|
|
QFileDevice__ExeGroup = QFileDevice__Permission(0x0010)
|
|
QFileDevice__ReadOther = QFileDevice__Permission(0x0004)
|
|
QFileDevice__WriteOther = QFileDevice__Permission(0x0002)
|
|
QFileDevice__ExeOther = QFileDevice__Permission(0x0001)
|
|
)
|
|
|
|
type QFileDevice struct {
|
|
QIODevice
|
|
}
|
|
|
|
type QFileDevice_ITF interface {
|
|
QIODevice_ITF
|
|
QFileDevice_PTR() *QFileDevice
|
|
}
|
|
|
|
func (p *QFileDevice) QFileDevice_PTR() *QFileDevice {
|
|
return p
|
|
}
|
|
|
|
func (p *QFileDevice) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QIODevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QFileDevice) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QIODevice_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQFileDevice(ptr QFileDevice_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFileDevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQFileDeviceFromPointer(ptr unsafe.Pointer) *QFileDevice {
|
|
var n = new(QFileDevice)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQFileDeviceFromPointer(ptr unsafe.Pointer) *QFileDevice {
|
|
var n = NewQFileDeviceFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QFileDevice_") {
|
|
n.SetObjectName("QFileDevice_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
//export callbackQFileDevice_Seek
|
|
func callbackQFileDevice_Seek(ptr unsafe.Pointer, ptrName *C.char, pos C.longlong) C.int {
|
|
defer qt.Recovering("callback QFileDevice::seek")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "seek"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int64) bool)(int64(pos))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).SeekDefault(int64(pos))))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectSeek(f func(pos int64) bool) {
|
|
defer qt.Recovering("connect QFileDevice::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "seek", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectSeek() {
|
|
defer qt.Recovering("disconnect QFileDevice::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "seek")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) Seek(pos int64) bool {
|
|
defer qt.Recovering("QFileDevice::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_Seek(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) SeekDefault(pos int64) bool {
|
|
defer qt.Recovering("QFileDevice::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_SeekDefault(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileDevice_AtEnd
|
|
func callbackQFileDevice_AtEnd(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QFileDevice::atEnd")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "atEnd"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).AtEndDefault()))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectAtEnd(f func() bool) {
|
|
defer qt.Recovering("connect QFileDevice::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "atEnd", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectAtEnd() {
|
|
defer qt.Recovering("disconnect QFileDevice::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "atEnd")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) AtEnd() bool {
|
|
defer qt.Recovering("QFileDevice::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_AtEnd(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) AtEndDefault() bool {
|
|
defer qt.Recovering("QFileDevice::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_AtEndDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileDevice_Close
|
|
func callbackQFileDevice_Close(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QFileDevice::close")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQFileDeviceFromPointer(ptr).CloseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectClose(f func()) {
|
|
defer qt.Recovering("connect QFileDevice::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "close", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectClose() {
|
|
defer qt.Recovering("disconnect QFileDevice::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "close")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) Close() {
|
|
defer qt.Recovering("QFileDevice::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_Close(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) CloseDefault() {
|
|
defer qt.Recovering("QFileDevice::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_CloseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) Error() QFileDevice__FileError {
|
|
defer qt.Recovering("QFileDevice::error")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QFileDevice__FileError(C.QFileDevice_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQFileDevice_FileName
|
|
func callbackQFileDevice_FileName(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QFileDevice::fileName")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "fileName"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString(NewQFileDeviceFromPointer(ptr).FileNameDefault())
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectFileName(f func() string) {
|
|
defer qt.Recovering("connect QFileDevice::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "fileName", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectFileName() {
|
|
defer qt.Recovering("disconnect QFileDevice::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "fileName")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) FileName() string {
|
|
defer qt.Recovering("QFileDevice::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileDevice_FileName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileDevice) FileNameDefault() string {
|
|
defer qt.Recovering("QFileDevice::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileDevice_FileNameDefault(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileDevice) Flush() bool {
|
|
defer qt.Recovering("QFileDevice::flush")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_Flush(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) Handle() int {
|
|
defer qt.Recovering("QFileDevice::handle")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QFileDevice_Handle(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQFileDevice_IsSequential
|
|
func callbackQFileDevice_IsSequential(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QFileDevice::isSequential")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "isSequential"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).IsSequentialDefault()))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectIsSequential(f func() bool) {
|
|
defer qt.Recovering("connect QFileDevice::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "isSequential", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectIsSequential() {
|
|
defer qt.Recovering("disconnect QFileDevice::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "isSequential")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) IsSequential() bool {
|
|
defer qt.Recovering("QFileDevice::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_IsSequential(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) IsSequentialDefault() bool {
|
|
defer qt.Recovering("QFileDevice::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_IsSequentialDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileDevice_Permissions
|
|
func callbackQFileDevice_Permissions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QFileDevice::permissions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "permissions"); signal != nil {
|
|
return C.int(signal.(func() QFileDevice__Permission)())
|
|
}
|
|
|
|
return C.int(NewQFileDeviceFromPointer(ptr).PermissionsDefault())
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectPermissions(f func() QFileDevice__Permission) {
|
|
defer qt.Recovering("connect QFileDevice::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "permissions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectPermissions() {
|
|
defer qt.Recovering("disconnect QFileDevice::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "permissions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) Permissions() QFileDevice__Permission {
|
|
defer qt.Recovering("QFileDevice::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QFileDevice__Permission(C.QFileDevice_Permissions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFileDevice) PermissionsDefault() QFileDevice__Permission {
|
|
defer qt.Recovering("QFileDevice::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QFileDevice__Permission(C.QFileDevice_PermissionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQFileDevice_Pos
|
|
func callbackQFileDevice_Pos(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QFileDevice::pos")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pos"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQFileDeviceFromPointer(ptr).PosDefault())
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectPos(f func() int64) {
|
|
defer qt.Recovering("connect QFileDevice::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pos", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectPos() {
|
|
defer qt.Recovering("disconnect QFileDevice::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pos")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) Pos() int64 {
|
|
defer qt.Recovering("QFileDevice::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileDevice_Pos(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFileDevice) PosDefault() int64 {
|
|
defer qt.Recovering("QFileDevice::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileDevice_PosDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQFileDevice_ReadLineData
|
|
func callbackQFileDevice_ReadLineData(ptr unsafe.Pointer, ptrName *C.char, data *C.char, maxlen C.longlong) C.longlong {
|
|
defer qt.Recovering("callback QFileDevice::readLineData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "readLineData"); signal != nil {
|
|
return C.longlong(signal.(func(string, int64) int64)(C.GoString(data), int64(maxlen)))
|
|
}
|
|
|
|
return C.longlong(NewQFileDeviceFromPointer(ptr).ReadLineDataDefault(C.GoString(data), int64(maxlen)))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectReadLineData(f func(data string, maxlen int64) int64) {
|
|
defer qt.Recovering("connect QFileDevice::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "readLineData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectReadLineData() {
|
|
defer qt.Recovering("disconnect QFileDevice::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "readLineData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) ReadLineData(data string, maxlen int64) int64 {
|
|
defer qt.Recovering("QFileDevice::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileDevice_ReadLineData(ptr.Pointer(), C.CString(data), C.longlong(maxlen)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFileDevice) ReadLineDataDefault(data string, maxlen int64) int64 {
|
|
defer qt.Recovering("QFileDevice::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileDevice_ReadLineDataDefault(ptr.Pointer(), C.CString(data), C.longlong(maxlen)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQFileDevice_Resize
|
|
func callbackQFileDevice_Resize(ptr unsafe.Pointer, ptrName *C.char, sz C.longlong) C.int {
|
|
defer qt.Recovering("callback QFileDevice::resize")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resize"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int64) bool)(int64(sz))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).ResizeDefault(int64(sz))))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectResize(f func(sz int64) bool) {
|
|
defer qt.Recovering("connect QFileDevice::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resize", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectResize() {
|
|
defer qt.Recovering("disconnect QFileDevice::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resize")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) Resize(sz int64) bool {
|
|
defer qt.Recovering("QFileDevice::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_Resize(ptr.Pointer(), C.longlong(sz)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) ResizeDefault(sz int64) bool {
|
|
defer qt.Recovering("QFileDevice::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_ResizeDefault(ptr.Pointer(), C.longlong(sz)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileDevice_SetPermissions
|
|
func callbackQFileDevice_SetPermissions(ptr unsafe.Pointer, ptrName *C.char, permissions C.int) C.int {
|
|
defer qt.Recovering("callback QFileDevice::setPermissions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setPermissions"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(QFileDevice__Permission) bool)(QFileDevice__Permission(permissions))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).SetPermissionsDefault(QFileDevice__Permission(permissions))))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectSetPermissions(f func(permissions QFileDevice__Permission) bool) {
|
|
defer qt.Recovering("connect QFileDevice::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setPermissions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectSetPermissions() {
|
|
defer qt.Recovering("disconnect QFileDevice::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setPermissions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) SetPermissions(permissions QFileDevice__Permission) bool {
|
|
defer qt.Recovering("QFileDevice::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_SetPermissions(ptr.Pointer(), C.int(permissions)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) SetPermissionsDefault(permissions QFileDevice__Permission) bool {
|
|
defer qt.Recovering("QFileDevice::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_SetPermissionsDefault(ptr.Pointer(), C.int(permissions)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileDevice_Size
|
|
func callbackQFileDevice_Size(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QFileDevice::size")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "size"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQFileDeviceFromPointer(ptr).SizeDefault())
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectSize(f func() int64) {
|
|
defer qt.Recovering("connect QFileDevice::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "size", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectSize() {
|
|
defer qt.Recovering("disconnect QFileDevice::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "size")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) Size() int64 {
|
|
defer qt.Recovering("QFileDevice::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileDevice_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFileDevice) SizeDefault() int64 {
|
|
defer qt.Recovering("QFileDevice::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileDevice_SizeDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFileDevice) UnsetError() {
|
|
defer qt.Recovering("QFileDevice::unsetError")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_UnsetError(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQFileDevice_WriteData
|
|
func callbackQFileDevice_WriteData(ptr unsafe.Pointer, ptrName *C.char, data *C.char, len C.longlong) C.longlong {
|
|
defer qt.Recovering("callback QFileDevice::writeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "writeData"); signal != nil {
|
|
return C.longlong(signal.(func(string, int64) int64)(C.GoString(data), int64(len)))
|
|
}
|
|
|
|
return C.longlong(NewQFileDeviceFromPointer(ptr).WriteDataDefault(C.GoString(data), int64(len)))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectWriteData(f func(data string, len int64) int64) {
|
|
defer qt.Recovering("connect QFileDevice::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "writeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectWriteData() {
|
|
defer qt.Recovering("disconnect QFileDevice::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "writeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) WriteData(data string, len int64) int64 {
|
|
defer qt.Recovering("QFileDevice::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileDevice_WriteData(ptr.Pointer(), C.CString(data), C.longlong(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFileDevice) WriteDataDefault(data string, len int64) int64 {
|
|
defer qt.Recovering("QFileDevice::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileDevice_WriteDataDefault(ptr.Pointer(), C.CString(data), C.longlong(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFileDevice) DestroyQFileDevice() {
|
|
defer qt.Recovering("QFileDevice::~QFileDevice")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QFileDevice_DestroyQFileDevice(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQFileDevice_BytesAvailable
|
|
func callbackQFileDevice_BytesAvailable(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QFileDevice::bytesAvailable")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesAvailable"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQFileDeviceFromPointer(ptr).BytesAvailableDefault())
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectBytesAvailable(f func() int64) {
|
|
defer qt.Recovering("connect QFileDevice::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesAvailable", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectBytesAvailable() {
|
|
defer qt.Recovering("disconnect QFileDevice::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) BytesAvailable() int64 {
|
|
defer qt.Recovering("QFileDevice::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileDevice_BytesAvailable(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFileDevice) BytesAvailableDefault() int64 {
|
|
defer qt.Recovering("QFileDevice::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileDevice_BytesAvailableDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQFileDevice_BytesToWrite
|
|
func callbackQFileDevice_BytesToWrite(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QFileDevice::bytesToWrite")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesToWrite"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQFileDeviceFromPointer(ptr).BytesToWriteDefault())
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectBytesToWrite(f func() int64) {
|
|
defer qt.Recovering("connect QFileDevice::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesToWrite", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectBytesToWrite() {
|
|
defer qt.Recovering("disconnect QFileDevice::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesToWrite")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) BytesToWrite() int64 {
|
|
defer qt.Recovering("QFileDevice::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileDevice_BytesToWrite(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFileDevice) BytesToWriteDefault() int64 {
|
|
defer qt.Recovering("QFileDevice::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileDevice_BytesToWriteDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQFileDevice_CanReadLine
|
|
func callbackQFileDevice_CanReadLine(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QFileDevice::canReadLine")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canReadLine"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).CanReadLineDefault()))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectCanReadLine(f func() bool) {
|
|
defer qt.Recovering("connect QFileDevice::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canReadLine", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectCanReadLine() {
|
|
defer qt.Recovering("disconnect QFileDevice::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canReadLine")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) CanReadLine() bool {
|
|
defer qt.Recovering("QFileDevice::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_CanReadLine(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) CanReadLineDefault() bool {
|
|
defer qt.Recovering("QFileDevice::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_CanReadLineDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileDevice_Open
|
|
func callbackQFileDevice_Open(ptr unsafe.Pointer, ptrName *C.char, mode C.int) C.int {
|
|
defer qt.Recovering("callback QFileDevice::open")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "open"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(QIODevice__OpenModeFlag) bool)(QIODevice__OpenModeFlag(mode))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).OpenDefault(QIODevice__OpenModeFlag(mode))))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectOpen(f func(mode QIODevice__OpenModeFlag) bool) {
|
|
defer qt.Recovering("connect QFileDevice::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "open", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectOpen() {
|
|
defer qt.Recovering("disconnect QFileDevice::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "open")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) Open(mode QIODevice__OpenModeFlag) bool {
|
|
defer qt.Recovering("QFileDevice::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_Open(ptr.Pointer(), C.int(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) OpenDefault(mode QIODevice__OpenModeFlag) bool {
|
|
defer qt.Recovering("QFileDevice::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_OpenDefault(ptr.Pointer(), C.int(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileDevice_Reset
|
|
func callbackQFileDevice_Reset(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QFileDevice::reset")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "reset"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).ResetDefault()))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectReset(f func() bool) {
|
|
defer qt.Recovering("connect QFileDevice::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "reset", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectReset() {
|
|
defer qt.Recovering("disconnect QFileDevice::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "reset")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) Reset() bool {
|
|
defer qt.Recovering("QFileDevice::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_Reset(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) ResetDefault() bool {
|
|
defer qt.Recovering("QFileDevice::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_ResetDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileDevice_WaitForBytesWritten
|
|
func callbackQFileDevice_WaitForBytesWritten(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) C.int {
|
|
defer qt.Recovering("callback QFileDevice::waitForBytesWritten")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "waitForBytesWritten"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(msecs))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).WaitForBytesWrittenDefault(int(msecs))))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectWaitForBytesWritten(f func(msecs int) bool) {
|
|
defer qt.Recovering("connect QFileDevice::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "waitForBytesWritten", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectWaitForBytesWritten() {
|
|
defer qt.Recovering("disconnect QFileDevice::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "waitForBytesWritten")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) WaitForBytesWritten(msecs int) bool {
|
|
defer qt.Recovering("QFileDevice::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_WaitForBytesWritten(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) WaitForBytesWrittenDefault(msecs int) bool {
|
|
defer qt.Recovering("QFileDevice::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_WaitForBytesWrittenDefault(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileDevice_WaitForReadyRead
|
|
func callbackQFileDevice_WaitForReadyRead(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) C.int {
|
|
defer qt.Recovering("callback QFileDevice::waitForReadyRead")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "waitForReadyRead"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(msecs))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).WaitForReadyReadDefault(int(msecs))))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectWaitForReadyRead(f func(msecs int) bool) {
|
|
defer qt.Recovering("connect QFileDevice::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "waitForReadyRead", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectWaitForReadyRead() {
|
|
defer qt.Recovering("disconnect QFileDevice::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "waitForReadyRead")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) WaitForReadyRead(msecs int) bool {
|
|
defer qt.Recovering("QFileDevice::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_WaitForReadyRead(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) WaitForReadyReadDefault(msecs int) bool {
|
|
defer qt.Recovering("QFileDevice::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_WaitForReadyReadDefault(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileDevice_TimerEvent
|
|
func callbackQFileDevice_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileDevice::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQFileDeviceFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QFileDevice::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QFileDevice::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QFileDevice::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QFileDevice::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileDevice_ChildEvent
|
|
func callbackQFileDevice_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileDevice::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQFileDeviceFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QFileDevice::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QFileDevice::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QFileDevice::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QFileDevice::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileDevice_ConnectNotify
|
|
func callbackQFileDevice_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileDevice::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQFileDeviceFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QFileDevice::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QFileDevice::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFileDevice::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFileDevice::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileDevice_CustomEvent
|
|
func callbackQFileDevice_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileDevice::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQFileDeviceFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QFileDevice::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QFileDevice::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QFileDevice::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QFileDevice::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileDevice_DeleteLater
|
|
func callbackQFileDevice_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QFileDevice::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQFileDeviceFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QFileDevice::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QFileDevice::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DeleteLater() {
|
|
defer qt.Recovering("QFileDevice::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QFileDevice_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DeleteLaterDefault() {
|
|
defer qt.Recovering("QFileDevice::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QFileDevice_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQFileDevice_DisconnectNotify
|
|
func callbackQFileDevice_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileDevice::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQFileDeviceFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QFileDevice::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QFileDevice::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFileDevice::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFileDevice::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileDevice_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileDevice_Event
|
|
func callbackQFileDevice_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QFileDevice::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QFileDevice::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QFileDevice::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QFileDevice::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QFileDevice::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileDevice_EventFilter
|
|
func callbackQFileDevice_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QFileDevice::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QFileDevice::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QFileDevice::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QFileDevice::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileDevice) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QFileDevice::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileDevice_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileDevice_MetaObject
|
|
func callbackQFileDevice_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QFileDevice::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQFileDeviceFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QFileDevice) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QFileDevice::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QFileDevice::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileDevice) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QFileDevice::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QFileDevice_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QFileDevice) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QFileDevice::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QFileDevice_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QFileInfo struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QFileInfo_ITF interface {
|
|
QFileInfo_PTR() *QFileInfo
|
|
}
|
|
|
|
func (p *QFileInfo) QFileInfo_PTR() *QFileInfo {
|
|
return p
|
|
}
|
|
|
|
func (p *QFileInfo) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QFileInfo) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQFileInfo(ptr QFileInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFileInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQFileInfoFromPointer(ptr unsafe.Pointer) *QFileInfo {
|
|
var n = new(QFileInfo)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQFileInfoFromPointer(ptr unsafe.Pointer) *QFileInfo {
|
|
var n = NewQFileInfoFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQFileInfo() *QFileInfo {
|
|
defer qt.Recovering("QFileInfo::QFileInfo")
|
|
|
|
return newQFileInfoFromPointer(C.QFileInfo_NewQFileInfo())
|
|
}
|
|
|
|
func NewQFileInfo5(dir QDir_ITF, file string) *QFileInfo {
|
|
defer qt.Recovering("QFileInfo::QFileInfo")
|
|
|
|
return newQFileInfoFromPointer(C.QFileInfo_NewQFileInfo5(PointerFromQDir(dir), C.CString(file)))
|
|
}
|
|
|
|
func NewQFileInfo4(file QFile_ITF) *QFileInfo {
|
|
defer qt.Recovering("QFileInfo::QFileInfo")
|
|
|
|
return newQFileInfoFromPointer(C.QFileInfo_NewQFileInfo4(PointerFromQFile(file)))
|
|
}
|
|
|
|
func NewQFileInfo6(fileinfo QFileInfo_ITF) *QFileInfo {
|
|
defer qt.Recovering("QFileInfo::QFileInfo")
|
|
|
|
return newQFileInfoFromPointer(C.QFileInfo_NewQFileInfo6(PointerFromQFileInfo(fileinfo)))
|
|
}
|
|
|
|
func NewQFileInfo3(file string) *QFileInfo {
|
|
defer qt.Recovering("QFileInfo::QFileInfo")
|
|
|
|
return newQFileInfoFromPointer(C.QFileInfo_NewQFileInfo3(C.CString(file)))
|
|
}
|
|
|
|
func (ptr *QFileInfo) AbsoluteDir() *QDir {
|
|
defer qt.Recovering("QFileInfo::absoluteDir")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDirFromPointer(C.QFileInfo_AbsoluteDir(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QFileInfo) AbsoluteFilePath() string {
|
|
defer qt.Recovering("QFileInfo::absoluteFilePath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_AbsoluteFilePath(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) AbsolutePath() string {
|
|
defer qt.Recovering("QFileInfo::absolutePath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_AbsolutePath(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) BaseName() string {
|
|
defer qt.Recovering("QFileInfo::baseName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_BaseName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) BundleName() string {
|
|
defer qt.Recovering("QFileInfo::bundleName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_BundleName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) Caching() bool {
|
|
defer qt.Recovering("QFileInfo::caching")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_Caching(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) CanonicalFilePath() string {
|
|
defer qt.Recovering("QFileInfo::canonicalFilePath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_CanonicalFilePath(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) CanonicalPath() string {
|
|
defer qt.Recovering("QFileInfo::canonicalPath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_CanonicalPath(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) CompleteBaseName() string {
|
|
defer qt.Recovering("QFileInfo::completeBaseName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_CompleteBaseName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) CompleteSuffix() string {
|
|
defer qt.Recovering("QFileInfo::completeSuffix")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_CompleteSuffix(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) Created() *QDateTime {
|
|
defer qt.Recovering("QFileInfo::created")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QFileInfo_Created(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QFileInfo) Dir() *QDir {
|
|
defer qt.Recovering("QFileInfo::dir")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDirFromPointer(C.QFileInfo_Dir(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func QFileInfo_Exists2(file string) bool {
|
|
defer qt.Recovering("QFileInfo::exists")
|
|
|
|
return C.QFileInfo_QFileInfo_Exists2(C.CString(file)) != 0
|
|
}
|
|
|
|
func (ptr *QFileInfo) Exists2(file string) bool {
|
|
defer qt.Recovering("QFileInfo::exists")
|
|
|
|
return C.QFileInfo_QFileInfo_Exists2(C.CString(file)) != 0
|
|
}
|
|
|
|
func (ptr *QFileInfo) Exists() bool {
|
|
defer qt.Recovering("QFileInfo::exists")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_Exists(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) FileName() string {
|
|
defer qt.Recovering("QFileInfo::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_FileName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) FilePath() string {
|
|
defer qt.Recovering("QFileInfo::filePath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_FilePath(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) Group() string {
|
|
defer qt.Recovering("QFileInfo::group")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_Group(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) IsAbsolute() bool {
|
|
defer qt.Recovering("QFileInfo::isAbsolute")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_IsAbsolute(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) IsBundle() bool {
|
|
defer qt.Recovering("QFileInfo::isBundle")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_IsBundle(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) IsDir() bool {
|
|
defer qt.Recovering("QFileInfo::isDir")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_IsDir(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) IsExecutable() bool {
|
|
defer qt.Recovering("QFileInfo::isExecutable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_IsExecutable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) IsFile() bool {
|
|
defer qt.Recovering("QFileInfo::isFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_IsFile(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) IsHidden() bool {
|
|
defer qt.Recovering("QFileInfo::isHidden")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_IsHidden(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) IsNativePath() bool {
|
|
defer qt.Recovering("QFileInfo::isNativePath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_IsNativePath(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) IsReadable() bool {
|
|
defer qt.Recovering("QFileInfo::isReadable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_IsReadable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) IsRelative() bool {
|
|
defer qt.Recovering("QFileInfo::isRelative")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_IsRelative(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) IsRoot() bool {
|
|
defer qt.Recovering("QFileInfo::isRoot")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_IsRoot(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) IsSymLink() bool {
|
|
defer qt.Recovering("QFileInfo::isSymLink")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_IsSymLink(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) IsWritable() bool {
|
|
defer qt.Recovering("QFileInfo::isWritable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_IsWritable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) LastModified() *QDateTime {
|
|
defer qt.Recovering("QFileInfo::lastModified")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QFileInfo_LastModified(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QFileInfo) LastRead() *QDateTime {
|
|
defer qt.Recovering("QFileInfo::lastRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QFileInfo_LastRead(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QFileInfo) MakeAbsolute() bool {
|
|
defer qt.Recovering("QFileInfo::makeAbsolute")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileInfo_MakeAbsolute(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileInfo) Owner() string {
|
|
defer qt.Recovering("QFileInfo::owner")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_Owner(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) Path() string {
|
|
defer qt.Recovering("QFileInfo::path")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_Path(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) Refresh() {
|
|
defer qt.Recovering("QFileInfo::refresh")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileInfo_Refresh(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileInfo) SetCaching(enable bool) {
|
|
defer qt.Recovering("QFileInfo::setCaching")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileInfo_SetCaching(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileInfo) SetFile3(dir QDir_ITF, file string) {
|
|
defer qt.Recovering("QFileInfo::setFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileInfo_SetFile3(ptr.Pointer(), PointerFromQDir(dir), C.CString(file))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileInfo) SetFile2(file QFile_ITF) {
|
|
defer qt.Recovering("QFileInfo::setFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileInfo_SetFile2(ptr.Pointer(), PointerFromQFile(file))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileInfo) SetFile(file string) {
|
|
defer qt.Recovering("QFileInfo::setFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileInfo_SetFile(ptr.Pointer(), C.CString(file))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileInfo) Size() int64 {
|
|
defer qt.Recovering("QFileInfo::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QFileInfo_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QFileInfo) Suffix() string {
|
|
defer qt.Recovering("QFileInfo::suffix")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_Suffix(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) Swap(other QFileInfo_ITF) {
|
|
defer qt.Recovering("QFileInfo::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileInfo_Swap(ptr.Pointer(), PointerFromQFileInfo(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileInfo) SymLinkTarget() string {
|
|
defer qt.Recovering("QFileInfo::symLinkTarget")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileInfo_SymLinkTarget(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileInfo) DestroyQFileInfo() {
|
|
defer qt.Recovering("QFileInfo::~QFileInfo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileInfo_DestroyQFileInfo(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QFileSelector struct {
|
|
QObject
|
|
}
|
|
|
|
type QFileSelector_ITF interface {
|
|
QObject_ITF
|
|
QFileSelector_PTR() *QFileSelector
|
|
}
|
|
|
|
func (p *QFileSelector) QFileSelector_PTR() *QFileSelector {
|
|
return p
|
|
}
|
|
|
|
func (p *QFileSelector) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QFileSelector) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQFileSelector(ptr QFileSelector_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFileSelector_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQFileSelectorFromPointer(ptr unsafe.Pointer) *QFileSelector {
|
|
var n = new(QFileSelector)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQFileSelectorFromPointer(ptr unsafe.Pointer) *QFileSelector {
|
|
var n = NewQFileSelectorFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QFileSelector_") {
|
|
n.SetObjectName("QFileSelector_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQFileSelector(parent QObject_ITF) *QFileSelector {
|
|
defer qt.Recovering("QFileSelector::QFileSelector")
|
|
|
|
return newQFileSelectorFromPointer(C.QFileSelector_NewQFileSelector(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QFileSelector) AllSelectors() []string {
|
|
defer qt.Recovering("QFileSelector::allSelectors")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QFileSelector_AllSelectors(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QFileSelector) ExtraSelectors() []string {
|
|
defer qt.Recovering("QFileSelector::extraSelectors")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QFileSelector_ExtraSelectors(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QFileSelector) Select(filePath string) string {
|
|
defer qt.Recovering("QFileSelector::select")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QFileSelector_Select(ptr.Pointer(), C.CString(filePath)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QFileSelector) Select2(filePath QUrl_ITF) *QUrl {
|
|
defer qt.Recovering("QFileSelector::select")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQUrlFromPointer(C.QFileSelector_Select2(ptr.Pointer(), PointerFromQUrl(filePath)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QFileSelector) SetExtraSelectors(list []string) {
|
|
defer qt.Recovering("QFileSelector::setExtraSelectors")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_SetExtraSelectors(ptr.Pointer(), C.CString(strings.Join(list, "|")))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DestroyQFileSelector() {
|
|
defer qt.Recovering("QFileSelector::~QFileSelector")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_DestroyQFileSelector(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSelector_TimerEvent
|
|
func callbackQFileSelector_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileSelector::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQFileSelectorFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QFileSelector::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QFileSelector::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QFileSelector::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QFileSelector::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSelector_ChildEvent
|
|
func callbackQFileSelector_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileSelector::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQFileSelectorFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QFileSelector::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QFileSelector::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QFileSelector::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QFileSelector::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSelector_ConnectNotify
|
|
func callbackQFileSelector_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileSelector::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQFileSelectorFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QFileSelector::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QFileSelector::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFileSelector::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFileSelector::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSelector_CustomEvent
|
|
func callbackQFileSelector_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileSelector::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQFileSelectorFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QFileSelector::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QFileSelector::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QFileSelector::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QFileSelector::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSelector_DeleteLater
|
|
func callbackQFileSelector_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QFileSelector::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQFileSelectorFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QFileSelector::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QFileSelector::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DeleteLater() {
|
|
defer qt.Recovering("QFileSelector::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DeleteLaterDefault() {
|
|
defer qt.Recovering("QFileSelector::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSelector_DisconnectNotify
|
|
func callbackQFileSelector_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileSelector::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQFileSelectorFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QFileSelector::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QFileSelector::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFileSelector::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFileSelector::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSelector_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSelector_Event
|
|
func callbackQFileSelector_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QFileSelector::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileSelectorFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QFileSelector) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QFileSelector::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QFileSelector::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QFileSelector::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileSelector_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileSelector) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QFileSelector::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileSelector_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileSelector_EventFilter
|
|
func callbackQFileSelector_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QFileSelector::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileSelectorFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QFileSelector) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QFileSelector::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QFileSelector::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QFileSelector::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileSelector_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileSelector) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QFileSelector::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileSelector_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileSelector_MetaObject
|
|
func callbackQFileSelector_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QFileSelector::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQFileSelectorFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QFileSelector) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QFileSelector::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QFileSelector::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSelector) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QFileSelector::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QFileSelector_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QFileSelector) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QFileSelector::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QFileSelector_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QFileSystemWatcher struct {
|
|
QObject
|
|
}
|
|
|
|
type QFileSystemWatcher_ITF interface {
|
|
QObject_ITF
|
|
QFileSystemWatcher_PTR() *QFileSystemWatcher
|
|
}
|
|
|
|
func (p *QFileSystemWatcher) QFileSystemWatcher_PTR() *QFileSystemWatcher {
|
|
return p
|
|
}
|
|
|
|
func (p *QFileSystemWatcher) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QFileSystemWatcher) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQFileSystemWatcher(ptr QFileSystemWatcher_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFileSystemWatcher_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQFileSystemWatcherFromPointer(ptr unsafe.Pointer) *QFileSystemWatcher {
|
|
var n = new(QFileSystemWatcher)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQFileSystemWatcherFromPointer(ptr unsafe.Pointer) *QFileSystemWatcher {
|
|
var n = NewQFileSystemWatcherFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QFileSystemWatcher_") {
|
|
n.SetObjectName("QFileSystemWatcher_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) Directories() []string {
|
|
defer qt.Recovering("QFileSystemWatcher::directories")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QFileSystemWatcher_Directories(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) Files() []string {
|
|
defer qt.Recovering("QFileSystemWatcher::files")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QFileSystemWatcher_Files(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func NewQFileSystemWatcher(parent QObject_ITF) *QFileSystemWatcher {
|
|
defer qt.Recovering("QFileSystemWatcher::QFileSystemWatcher")
|
|
|
|
return newQFileSystemWatcherFromPointer(C.QFileSystemWatcher_NewQFileSystemWatcher(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQFileSystemWatcher2(paths []string, parent QObject_ITF) *QFileSystemWatcher {
|
|
defer qt.Recovering("QFileSystemWatcher::QFileSystemWatcher")
|
|
|
|
return newQFileSystemWatcherFromPointer(C.QFileSystemWatcher_NewQFileSystemWatcher2(C.CString(strings.Join(paths, "|")), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) AddPath(path string) bool {
|
|
defer qt.Recovering("QFileSystemWatcher::addPath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileSystemWatcher_AddPath(ptr.Pointer(), C.CString(path)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) AddPaths(paths []string) []string {
|
|
defer qt.Recovering("QFileSystemWatcher::addPaths")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QFileSystemWatcher_AddPaths(ptr.Pointer(), C.CString(strings.Join(paths, "|")))), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQFileSystemWatcher_DirectoryChanged
|
|
func callbackQFileSystemWatcher_DirectoryChanged(ptr unsafe.Pointer, ptrName *C.char, path *C.char) {
|
|
defer qt.Recovering("callback QFileSystemWatcher::directoryChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "directoryChanged"); signal != nil {
|
|
signal.(func(string))(C.GoString(path))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectDirectoryChanged(f func(path string)) {
|
|
defer qt.Recovering("connect QFileSystemWatcher::directoryChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_ConnectDirectoryChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "directoryChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectDirectoryChanged() {
|
|
defer qt.Recovering("disconnect QFileSystemWatcher::directoryChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_DisconnectDirectoryChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "directoryChanged")
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSystemWatcher_FileChanged
|
|
func callbackQFileSystemWatcher_FileChanged(ptr unsafe.Pointer, ptrName *C.char, path *C.char) {
|
|
defer qt.Recovering("callback QFileSystemWatcher::fileChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "fileChanged"); signal != nil {
|
|
signal.(func(string))(C.GoString(path))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectFileChanged(f func(path string)) {
|
|
defer qt.Recovering("connect QFileSystemWatcher::fileChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_ConnectFileChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "fileChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectFileChanged() {
|
|
defer qt.Recovering("disconnect QFileSystemWatcher::fileChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_DisconnectFileChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "fileChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) RemovePath(path string) bool {
|
|
defer qt.Recovering("QFileSystemWatcher::removePath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileSystemWatcher_RemovePath(ptr.Pointer(), C.CString(path)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) RemovePaths(paths []string) []string {
|
|
defer qt.Recovering("QFileSystemWatcher::removePaths")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QFileSystemWatcher_RemovePaths(ptr.Pointer(), C.CString(strings.Join(paths, "|")))), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DestroyQFileSystemWatcher() {
|
|
defer qt.Recovering("QFileSystemWatcher::~QFileSystemWatcher")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QFileSystemWatcher_DestroyQFileSystemWatcher(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSystemWatcher_TimerEvent
|
|
func callbackQFileSystemWatcher_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileSystemWatcher::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQFileSystemWatcherFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QFileSystemWatcher::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QFileSystemWatcher::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QFileSystemWatcher::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QFileSystemWatcher::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSystemWatcher_ChildEvent
|
|
func callbackQFileSystemWatcher_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileSystemWatcher::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQFileSystemWatcherFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QFileSystemWatcher::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QFileSystemWatcher::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QFileSystemWatcher::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QFileSystemWatcher::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSystemWatcher_ConnectNotify
|
|
func callbackQFileSystemWatcher_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileSystemWatcher::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQFileSystemWatcherFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QFileSystemWatcher::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QFileSystemWatcher::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFileSystemWatcher::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFileSystemWatcher::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSystemWatcher_CustomEvent
|
|
func callbackQFileSystemWatcher_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileSystemWatcher::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQFileSystemWatcherFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QFileSystemWatcher::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QFileSystemWatcher::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QFileSystemWatcher::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QFileSystemWatcher::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSystemWatcher_DeleteLater
|
|
func callbackQFileSystemWatcher_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QFileSystemWatcher::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQFileSystemWatcherFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QFileSystemWatcher::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QFileSystemWatcher::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DeleteLater() {
|
|
defer qt.Recovering("QFileSystemWatcher::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QFileSystemWatcher_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DeleteLaterDefault() {
|
|
defer qt.Recovering("QFileSystemWatcher::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QFileSystemWatcher_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSystemWatcher_DisconnectNotify
|
|
func callbackQFileSystemWatcher_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFileSystemWatcher::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQFileSystemWatcherFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QFileSystemWatcher::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QFileSystemWatcher::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFileSystemWatcher::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFileSystemWatcher::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFileSystemWatcher_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQFileSystemWatcher_Event
|
|
func callbackQFileSystemWatcher_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QFileSystemWatcher::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileSystemWatcherFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QFileSystemWatcher::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QFileSystemWatcher::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QFileSystemWatcher::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileSystemWatcher_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QFileSystemWatcher::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileSystemWatcher_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileSystemWatcher_EventFilter
|
|
func callbackQFileSystemWatcher_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QFileSystemWatcher::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFileSystemWatcherFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QFileSystemWatcher::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QFileSystemWatcher::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QFileSystemWatcher::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileSystemWatcher_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QFileSystemWatcher::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFileSystemWatcher_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFileSystemWatcher_MetaObject
|
|
func callbackQFileSystemWatcher_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QFileSystemWatcher::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQFileSystemWatcherFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QFileSystemWatcher::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QFileSystemWatcher::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QFileSystemWatcher::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QFileSystemWatcher_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QFileSystemWatcher) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QFileSystemWatcher::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QFileSystemWatcher_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QFinalState struct {
|
|
QAbstractState
|
|
}
|
|
|
|
type QFinalState_ITF interface {
|
|
QAbstractState_ITF
|
|
QFinalState_PTR() *QFinalState
|
|
}
|
|
|
|
func (p *QFinalState) QFinalState_PTR() *QFinalState {
|
|
return p
|
|
}
|
|
|
|
func (p *QFinalState) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractState_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QFinalState) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractState_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQFinalState(ptr QFinalState_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFinalState_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQFinalStateFromPointer(ptr unsafe.Pointer) *QFinalState {
|
|
var n = new(QFinalState)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQFinalStateFromPointer(ptr unsafe.Pointer) *QFinalState {
|
|
var n = NewQFinalStateFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QFinalState_") {
|
|
n.SetObjectName("QFinalState_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQFinalState(parent QState_ITF) *QFinalState {
|
|
defer qt.Recovering("QFinalState::QFinalState")
|
|
|
|
return newQFinalStateFromPointer(C.QFinalState_NewQFinalState(PointerFromQState(parent)))
|
|
}
|
|
|
|
//export callbackQFinalState_Event
|
|
func callbackQFinalState_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QFinalState::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFinalStateFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QFinalState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QFinalState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QFinalState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFinalState_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFinalState) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QFinalState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFinalState_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFinalState_OnEntry
|
|
func callbackQFinalState_OnEntry(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFinalState::onEntry")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onEntry"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQFinalStateFromPointer(ptr).OnEntryDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectOnEntry(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QFinalState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onEntry", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectOnEntry() {
|
|
defer qt.Recovering("disconnect QFinalState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onEntry")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) OnEntry(event QEvent_ITF) {
|
|
defer qt.Recovering("QFinalState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) OnEntryDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QFinalState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_OnEntryDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFinalState_OnExit
|
|
func callbackQFinalState_OnExit(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFinalState::onExit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onExit"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQFinalStateFromPointer(ptr).OnExitDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectOnExit(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QFinalState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onExit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectOnExit() {
|
|
defer qt.Recovering("disconnect QFinalState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onExit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) OnExit(event QEvent_ITF) {
|
|
defer qt.Recovering("QFinalState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_OnExit(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) OnExitDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QFinalState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_OnExitDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DestroyQFinalState() {
|
|
defer qt.Recovering("QFinalState::~QFinalState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QFinalState_DestroyQFinalState(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQFinalState_TimerEvent
|
|
func callbackQFinalState_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFinalState::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQFinalStateFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QFinalState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QFinalState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QFinalState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QFinalState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFinalState_ChildEvent
|
|
func callbackQFinalState_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFinalState::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQFinalStateFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QFinalState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QFinalState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QFinalState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QFinalState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFinalState_ConnectNotify
|
|
func callbackQFinalState_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFinalState::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQFinalStateFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QFinalState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QFinalState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFinalState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFinalState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQFinalState_CustomEvent
|
|
func callbackQFinalState_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFinalState::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQFinalStateFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QFinalState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QFinalState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QFinalState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QFinalState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQFinalState_DeleteLater
|
|
func callbackQFinalState_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QFinalState::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQFinalStateFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QFinalState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QFinalState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DeleteLater() {
|
|
defer qt.Recovering("QFinalState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QFinalState_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DeleteLaterDefault() {
|
|
defer qt.Recovering("QFinalState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QFinalState_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQFinalState_DisconnectNotify
|
|
func callbackQFinalState_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QFinalState::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQFinalStateFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QFinalState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QFinalState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFinalState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QFinalState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QFinalState_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQFinalState_EventFilter
|
|
func callbackQFinalState_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QFinalState::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQFinalStateFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QFinalState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QFinalState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QFinalState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFinalState_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QFinalState) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QFinalState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QFinalState_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQFinalState_MetaObject
|
|
func callbackQFinalState_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QFinalState::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQFinalStateFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QFinalState) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QFinalState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QFinalState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QFinalState) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QFinalState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QFinalState_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QFinalState) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QFinalState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QFinalState_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QFlag struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QFlag_ITF interface {
|
|
QFlag_PTR() *QFlag
|
|
}
|
|
|
|
func (p *QFlag) QFlag_PTR() *QFlag {
|
|
return p
|
|
}
|
|
|
|
func (p *QFlag) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QFlag) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQFlag(ptr QFlag_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFlag_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQFlagFromPointer(ptr unsafe.Pointer) *QFlag {
|
|
var n = new(QFlag)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQFlagFromPointer(ptr unsafe.Pointer) *QFlag {
|
|
var n = NewQFlagFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQFlag(value int) *QFlag {
|
|
defer qt.Recovering("QFlag::QFlag")
|
|
|
|
return newQFlagFromPointer(C.QFlag_NewQFlag(C.int(value)))
|
|
}
|
|
|
|
type QFlags struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QFlags_ITF interface {
|
|
QFlags_PTR() *QFlags
|
|
}
|
|
|
|
func (p *QFlags) QFlags_PTR() *QFlags {
|
|
return p
|
|
}
|
|
|
|
func (p *QFlags) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QFlags) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQFlags(ptr QFlags_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFlags_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQFlagsFromPointer(ptr unsafe.Pointer) *QFlags {
|
|
var n = new(QFlags)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQFlagsFromPointer(ptr unsafe.Pointer) *QFlags {
|
|
var n = NewQFlagsFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QFuture struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QFuture_ITF interface {
|
|
QFuture_PTR() *QFuture
|
|
}
|
|
|
|
func (p *QFuture) QFuture_PTR() *QFuture {
|
|
return p
|
|
}
|
|
|
|
func (p *QFuture) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QFuture) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQFuture(ptr QFuture_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFuture_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQFutureFromPointer(ptr unsafe.Pointer) *QFuture {
|
|
var n = new(QFuture)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQFutureFromPointer(ptr unsafe.Pointer) *QFuture {
|
|
var n = NewQFutureFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QFutureIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QFutureIterator_ITF interface {
|
|
QFutureIterator_PTR() *QFutureIterator
|
|
}
|
|
|
|
func (p *QFutureIterator) QFutureIterator_PTR() *QFutureIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QFutureIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QFutureIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQFutureIterator(ptr QFutureIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFutureIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQFutureIteratorFromPointer(ptr unsafe.Pointer) *QFutureIterator {
|
|
var n = new(QFutureIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQFutureIteratorFromPointer(ptr unsafe.Pointer) *QFutureIterator {
|
|
var n = NewQFutureIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QFutureSynchronizer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QFutureSynchronizer_ITF interface {
|
|
QFutureSynchronizer_PTR() *QFutureSynchronizer
|
|
}
|
|
|
|
func (p *QFutureSynchronizer) QFutureSynchronizer_PTR() *QFutureSynchronizer {
|
|
return p
|
|
}
|
|
|
|
func (p *QFutureSynchronizer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QFutureSynchronizer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQFutureSynchronizer(ptr QFutureSynchronizer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFutureSynchronizer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQFutureSynchronizerFromPointer(ptr unsafe.Pointer) *QFutureSynchronizer {
|
|
var n = new(QFutureSynchronizer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQFutureSynchronizerFromPointer(ptr unsafe.Pointer) *QFutureSynchronizer {
|
|
var n = NewQFutureSynchronizerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QFutureWatcher struct {
|
|
QObject
|
|
}
|
|
|
|
type QFutureWatcher_ITF interface {
|
|
QObject_ITF
|
|
QFutureWatcher_PTR() *QFutureWatcher
|
|
}
|
|
|
|
func (p *QFutureWatcher) QFutureWatcher_PTR() *QFutureWatcher {
|
|
return p
|
|
}
|
|
|
|
func (p *QFutureWatcher) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QFutureWatcher) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQFutureWatcher(ptr QFutureWatcher_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFutureWatcher_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQFutureWatcherFromPointer(ptr unsafe.Pointer) *QFutureWatcher {
|
|
var n = new(QFutureWatcher)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQFutureWatcherFromPointer(ptr unsafe.Pointer) *QFutureWatcher {
|
|
var n = NewQFutureWatcherFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QGenericArgument struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QGenericArgument_ITF interface {
|
|
QGenericArgument_PTR() *QGenericArgument
|
|
}
|
|
|
|
func (p *QGenericArgument) QGenericArgument_PTR() *QGenericArgument {
|
|
return p
|
|
}
|
|
|
|
func (p *QGenericArgument) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QGenericArgument) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQGenericArgument(ptr QGenericArgument_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGenericArgument_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGenericArgumentFromPointer(ptr unsafe.Pointer) *QGenericArgument {
|
|
var n = new(QGenericArgument)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQGenericArgumentFromPointer(ptr unsafe.Pointer) *QGenericArgument {
|
|
var n = NewQGenericArgumentFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQGenericArgument(name string, data unsafe.Pointer) *QGenericArgument {
|
|
defer qt.Recovering("QGenericArgument::QGenericArgument")
|
|
|
|
return newQGenericArgumentFromPointer(C.QGenericArgument_NewQGenericArgument(C.CString(name), data))
|
|
}
|
|
|
|
func (ptr *QGenericArgument) Data() unsafe.Pointer {
|
|
defer qt.Recovering("QGenericArgument::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QGenericArgument_Data(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGenericArgument) Name() string {
|
|
defer qt.Recovering("QGenericArgument::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QGenericArgument_Name(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type QGenericReturnArgument struct {
|
|
QGenericArgument
|
|
}
|
|
|
|
type QGenericReturnArgument_ITF interface {
|
|
QGenericArgument_ITF
|
|
QGenericReturnArgument_PTR() *QGenericReturnArgument
|
|
}
|
|
|
|
func (p *QGenericReturnArgument) QGenericReturnArgument_PTR() *QGenericReturnArgument {
|
|
return p
|
|
}
|
|
|
|
func (p *QGenericReturnArgument) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QGenericArgument_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QGenericReturnArgument) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QGenericArgument_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGenericReturnArgument(ptr QGenericReturnArgument_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGenericReturnArgument_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGenericReturnArgumentFromPointer(ptr unsafe.Pointer) *QGenericReturnArgument {
|
|
var n = new(QGenericReturnArgument)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQGenericReturnArgumentFromPointer(ptr unsafe.Pointer) *QGenericReturnArgument {
|
|
var n = NewQGenericReturnArgumentFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQGenericReturnArgument(name string, data unsafe.Pointer) *QGenericReturnArgument {
|
|
defer qt.Recovering("QGenericReturnArgument::QGenericReturnArgument")
|
|
|
|
return newQGenericReturnArgumentFromPointer(C.QGenericReturnArgument_NewQGenericReturnArgument(C.CString(name), data))
|
|
}
|
|
|
|
type QGlobalStatic struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QGlobalStatic_ITF interface {
|
|
QGlobalStatic_PTR() *QGlobalStatic
|
|
}
|
|
|
|
func (p *QGlobalStatic) QGlobalStatic_PTR() *QGlobalStatic {
|
|
return p
|
|
}
|
|
|
|
func (p *QGlobalStatic) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QGlobalStatic) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQGlobalStatic(ptr QGlobalStatic_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGlobalStatic_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGlobalStaticFromPointer(ptr unsafe.Pointer) *QGlobalStatic {
|
|
var n = new(QGlobalStatic)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQGlobalStaticFromPointer(ptr unsafe.Pointer) *QGlobalStatic {
|
|
var n = NewQGlobalStaticFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QHash struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QHash_ITF interface {
|
|
QHash_PTR() *QHash
|
|
}
|
|
|
|
func (p *QHash) QHash_PTR() *QHash {
|
|
return p
|
|
}
|
|
|
|
func (p *QHash) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QHash) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQHash(ptr QHash_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QHash_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQHashFromPointer(ptr unsafe.Pointer) *QHash {
|
|
var n = new(QHash)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQHashFromPointer(ptr unsafe.Pointer) *QHash {
|
|
var n = NewQHashFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QHashIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QHashIterator_ITF interface {
|
|
QHashIterator_PTR() *QHashIterator
|
|
}
|
|
|
|
func (p *QHashIterator) QHashIterator_PTR() *QHashIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QHashIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QHashIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQHashIterator(ptr QHashIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QHashIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQHashIteratorFromPointer(ptr unsafe.Pointer) *QHashIterator {
|
|
var n = new(QHashIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQHashIteratorFromPointer(ptr unsafe.Pointer) *QHashIterator {
|
|
var n = NewQHashIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QHistoryState::HistoryType
|
|
type QHistoryState__HistoryType int64
|
|
|
|
const (
|
|
QHistoryState__ShallowHistory = QHistoryState__HistoryType(0)
|
|
QHistoryState__DeepHistory = QHistoryState__HistoryType(1)
|
|
)
|
|
|
|
type QHistoryState struct {
|
|
QAbstractState
|
|
}
|
|
|
|
type QHistoryState_ITF interface {
|
|
QAbstractState_ITF
|
|
QHistoryState_PTR() *QHistoryState
|
|
}
|
|
|
|
func (p *QHistoryState) QHistoryState_PTR() *QHistoryState {
|
|
return p
|
|
}
|
|
|
|
func (p *QHistoryState) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractState_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QHistoryState) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractState_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQHistoryState(ptr QHistoryState_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QHistoryState_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQHistoryStateFromPointer(ptr unsafe.Pointer) *QHistoryState {
|
|
var n = new(QHistoryState)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQHistoryStateFromPointer(ptr unsafe.Pointer) *QHistoryState {
|
|
var n = NewQHistoryStateFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QHistoryState_") {
|
|
n.SetObjectName("QHistoryState_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQHistoryState2(ty QHistoryState__HistoryType, parent QState_ITF) *QHistoryState {
|
|
defer qt.Recovering("QHistoryState::QHistoryState")
|
|
|
|
return newQHistoryStateFromPointer(C.QHistoryState_NewQHistoryState2(C.int(ty), PointerFromQState(parent)))
|
|
}
|
|
|
|
func NewQHistoryState(parent QState_ITF) *QHistoryState {
|
|
defer qt.Recovering("QHistoryState::QHistoryState")
|
|
|
|
return newQHistoryStateFromPointer(C.QHistoryState_NewQHistoryState(PointerFromQState(parent)))
|
|
}
|
|
|
|
func (ptr *QHistoryState) DefaultState() *QAbstractState {
|
|
defer qt.Recovering("QHistoryState::defaultState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractStateFromPointer(C.QHistoryState_DefaultState(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQHistoryState_DefaultStateChanged
|
|
func callbackQHistoryState_DefaultStateChanged(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QHistoryState::defaultStateChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "defaultStateChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectDefaultStateChanged(f func()) {
|
|
defer qt.Recovering("connect QHistoryState::defaultStateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_ConnectDefaultStateChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "defaultStateChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectDefaultStateChanged() {
|
|
defer qt.Recovering("disconnect QHistoryState::defaultStateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_DisconnectDefaultStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "defaultStateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DefaultTransition() *QAbstractTransition {
|
|
defer qt.Recovering("QHistoryState::defaultTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractTransitionFromPointer(C.QHistoryState_DefaultTransition(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQHistoryState_DefaultTransitionChanged
|
|
func callbackQHistoryState_DefaultTransitionChanged(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QHistoryState::defaultTransitionChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "defaultTransitionChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectDefaultTransitionChanged(f func()) {
|
|
defer qt.Recovering("connect QHistoryState::defaultTransitionChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_ConnectDefaultTransitionChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "defaultTransitionChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectDefaultTransitionChanged() {
|
|
defer qt.Recovering("disconnect QHistoryState::defaultTransitionChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_DisconnectDefaultTransitionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "defaultTransitionChanged")
|
|
}
|
|
}
|
|
|
|
//export callbackQHistoryState_Event
|
|
func callbackQHistoryState_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QHistoryState::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQHistoryStateFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QHistoryState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QHistoryState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QHistoryState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QHistoryState_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QHistoryState) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QHistoryState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QHistoryState_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QHistoryState) HistoryType() QHistoryState__HistoryType {
|
|
defer qt.Recovering("QHistoryState::historyType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QHistoryState__HistoryType(C.QHistoryState_HistoryType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQHistoryState_HistoryTypeChanged
|
|
func callbackQHistoryState_HistoryTypeChanged(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QHistoryState::historyTypeChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "historyTypeChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectHistoryTypeChanged(f func()) {
|
|
defer qt.Recovering("connect QHistoryState::historyTypeChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_ConnectHistoryTypeChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "historyTypeChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectHistoryTypeChanged() {
|
|
defer qt.Recovering("disconnect QHistoryState::historyTypeChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_DisconnectHistoryTypeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "historyTypeChanged")
|
|
}
|
|
}
|
|
|
|
//export callbackQHistoryState_OnEntry
|
|
func callbackQHistoryState_OnEntry(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QHistoryState::onEntry")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onEntry"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQHistoryStateFromPointer(ptr).OnEntryDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectOnEntry(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QHistoryState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onEntry", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectOnEntry() {
|
|
defer qt.Recovering("disconnect QHistoryState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onEntry")
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) OnEntry(event QEvent_ITF) {
|
|
defer qt.Recovering("QHistoryState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) OnEntryDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QHistoryState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_OnEntryDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQHistoryState_OnExit
|
|
func callbackQHistoryState_OnExit(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QHistoryState::onExit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onExit"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQHistoryStateFromPointer(ptr).OnExitDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectOnExit(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QHistoryState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onExit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectOnExit() {
|
|
defer qt.Recovering("disconnect QHistoryState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onExit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) OnExit(event QEvent_ITF) {
|
|
defer qt.Recovering("QHistoryState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_OnExit(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) OnExitDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QHistoryState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_OnExitDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) SetDefaultState(state QAbstractState_ITF) {
|
|
defer qt.Recovering("QHistoryState::setDefaultState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_SetDefaultState(ptr.Pointer(), PointerFromQAbstractState(state))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) SetDefaultTransition(transition QAbstractTransition_ITF) {
|
|
defer qt.Recovering("QHistoryState::setDefaultTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_SetDefaultTransition(ptr.Pointer(), PointerFromQAbstractTransition(transition))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) SetHistoryType(ty QHistoryState__HistoryType) {
|
|
defer qt.Recovering("QHistoryState::setHistoryType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_SetHistoryType(ptr.Pointer(), C.int(ty))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DestroyQHistoryState() {
|
|
defer qt.Recovering("QHistoryState::~QHistoryState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QHistoryState_DestroyQHistoryState(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQHistoryState_TimerEvent
|
|
func callbackQHistoryState_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QHistoryState::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQHistoryStateFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QHistoryState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QHistoryState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QHistoryState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QHistoryState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQHistoryState_ChildEvent
|
|
func callbackQHistoryState_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QHistoryState::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQHistoryStateFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QHistoryState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QHistoryState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QHistoryState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QHistoryState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQHistoryState_ConnectNotify
|
|
func callbackQHistoryState_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QHistoryState::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQHistoryStateFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QHistoryState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QHistoryState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QHistoryState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QHistoryState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQHistoryState_CustomEvent
|
|
func callbackQHistoryState_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QHistoryState::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQHistoryStateFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QHistoryState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QHistoryState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QHistoryState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QHistoryState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQHistoryState_DeleteLater
|
|
func callbackQHistoryState_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QHistoryState::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQHistoryStateFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QHistoryState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QHistoryState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DeleteLater() {
|
|
defer qt.Recovering("QHistoryState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QHistoryState_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DeleteLaterDefault() {
|
|
defer qt.Recovering("QHistoryState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QHistoryState_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQHistoryState_DisconnectNotify
|
|
func callbackQHistoryState_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QHistoryState::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQHistoryStateFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QHistoryState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QHistoryState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QHistoryState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QHistoryState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QHistoryState_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQHistoryState_EventFilter
|
|
func callbackQHistoryState_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QHistoryState::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQHistoryStateFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QHistoryState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QHistoryState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QHistoryState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QHistoryState_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QHistoryState) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QHistoryState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QHistoryState_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQHistoryState_MetaObject
|
|
func callbackQHistoryState_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QHistoryState::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQHistoryStateFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QHistoryState) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QHistoryState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QHistoryState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QHistoryState) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QHistoryState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QHistoryState_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QHistoryState) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QHistoryState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QHistoryState_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//QHooks::HookIndex
|
|
type QHooks__HookIndex int64
|
|
|
|
const (
|
|
QHooks__HookDataVersion = QHooks__HookIndex(0)
|
|
QHooks__HookDataSize = QHooks__HookIndex(1)
|
|
QHooks__QtVersion = QHooks__HookIndex(2)
|
|
QHooks__AddQObject = QHooks__HookIndex(3)
|
|
QHooks__RemoveQObject = QHooks__HookIndex(4)
|
|
QHooks__Startup = QHooks__HookIndex(5)
|
|
QHooks__LastHookIndex = QHooks__HookIndex(6)
|
|
)
|
|
|
|
type QHooks struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QHooks_ITF interface {
|
|
QHooks_PTR() *QHooks
|
|
}
|
|
|
|
func (p *QHooks) QHooks_PTR() *QHooks {
|
|
return p
|
|
}
|
|
|
|
func (p *QHooks) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QHooks) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQHooks(ptr QHooks_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QHooks_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQHooksFromPointer(ptr unsafe.Pointer) *QHooks {
|
|
var n = new(QHooks)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQHooksFromPointer(ptr unsafe.Pointer) *QHooks {
|
|
var n = NewQHooksFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QIODevice::OpenModeFlag
|
|
type QIODevice__OpenModeFlag int64
|
|
|
|
const (
|
|
QIODevice__NotOpen = QIODevice__OpenModeFlag(0x0000)
|
|
QIODevice__ReadOnly = QIODevice__OpenModeFlag(0x0001)
|
|
QIODevice__WriteOnly = QIODevice__OpenModeFlag(0x0002)
|
|
QIODevice__ReadWrite = QIODevice__OpenModeFlag(QIODevice__ReadOnly | QIODevice__WriteOnly)
|
|
QIODevice__Append = QIODevice__OpenModeFlag(0x0004)
|
|
QIODevice__Truncate = QIODevice__OpenModeFlag(0x0008)
|
|
QIODevice__Text = QIODevice__OpenModeFlag(0x0010)
|
|
QIODevice__Unbuffered = QIODevice__OpenModeFlag(0x0020)
|
|
)
|
|
|
|
type QIODevice struct {
|
|
QObject
|
|
}
|
|
|
|
type QIODevice_ITF interface {
|
|
QObject_ITF
|
|
QIODevice_PTR() *QIODevice
|
|
}
|
|
|
|
func (p *QIODevice) QIODevice_PTR() *QIODevice {
|
|
return p
|
|
}
|
|
|
|
func (p *QIODevice) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QIODevice) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQIODevice(ptr QIODevice_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QIODevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQIODeviceFromPointer(ptr unsafe.Pointer) *QIODevice {
|
|
var n = new(QIODevice)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQIODeviceFromPointer(ptr unsafe.Pointer) *QIODevice {
|
|
var n = NewQIODeviceFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QIODevice_") {
|
|
n.SetObjectName("QIODevice_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QIODevice) GetChar(c string) bool {
|
|
defer qt.Recovering("QIODevice::getChar")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_GetChar(ptr.Pointer(), C.CString(c)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) PutChar(c string) bool {
|
|
defer qt.Recovering("QIODevice::putChar")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_PutChar(ptr.Pointer(), C.CString(c)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIODevice_AboutToClose
|
|
func callbackQIODevice_AboutToClose(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QIODevice::aboutToClose")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "aboutToClose"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectAboutToClose(f func()) {
|
|
defer qt.Recovering("connect QIODevice::aboutToClose")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_ConnectAboutToClose(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "aboutToClose", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectAboutToClose() {
|
|
defer qt.Recovering("disconnect QIODevice::aboutToClose")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_DisconnectAboutToClose(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "aboutToClose")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) AboutToClose() {
|
|
defer qt.Recovering("QIODevice::aboutToClose")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_AboutToClose(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQIODevice_AtEnd
|
|
func callbackQIODevice_AtEnd(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QIODevice::atEnd")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "atEnd"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).AtEndDefault()))
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectAtEnd(f func() bool) {
|
|
defer qt.Recovering("connect QIODevice::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "atEnd", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectAtEnd() {
|
|
defer qt.Recovering("disconnect QIODevice::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "atEnd")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) AtEnd() bool {
|
|
defer qt.Recovering("QIODevice::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_AtEnd(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) AtEndDefault() bool {
|
|
defer qt.Recovering("QIODevice::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_AtEndDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIODevice_BytesAvailable
|
|
func callbackQIODevice_BytesAvailable(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QIODevice::bytesAvailable")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesAvailable"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQIODeviceFromPointer(ptr).BytesAvailableDefault())
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectBytesAvailable(f func() int64) {
|
|
defer qt.Recovering("connect QIODevice::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesAvailable", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectBytesAvailable() {
|
|
defer qt.Recovering("disconnect QIODevice::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) BytesAvailable() int64 {
|
|
defer qt.Recovering("QIODevice::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_BytesAvailable(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIODevice) BytesAvailableDefault() int64 {
|
|
defer qt.Recovering("QIODevice::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_BytesAvailableDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQIODevice_BytesToWrite
|
|
func callbackQIODevice_BytesToWrite(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QIODevice::bytesToWrite")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesToWrite"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQIODeviceFromPointer(ptr).BytesToWriteDefault())
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectBytesToWrite(f func() int64) {
|
|
defer qt.Recovering("connect QIODevice::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesToWrite", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectBytesToWrite() {
|
|
defer qt.Recovering("disconnect QIODevice::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesToWrite")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) BytesToWrite() int64 {
|
|
defer qt.Recovering("QIODevice::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_BytesToWrite(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIODevice) BytesToWriteDefault() int64 {
|
|
defer qt.Recovering("QIODevice::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_BytesToWriteDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQIODevice_BytesWritten
|
|
func callbackQIODevice_BytesWritten(ptr unsafe.Pointer, ptrName *C.char, bytes C.longlong) {
|
|
defer qt.Recovering("callback QIODevice::bytesWritten")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesWritten"); signal != nil {
|
|
signal.(func(int64))(int64(bytes))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectBytesWritten(f func(bytes int64)) {
|
|
defer qt.Recovering("connect QIODevice::bytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_ConnectBytesWritten(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesWritten", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectBytesWritten() {
|
|
defer qt.Recovering("disconnect QIODevice::bytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_DisconnectBytesWritten(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesWritten")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) BytesWritten(bytes int64) {
|
|
defer qt.Recovering("QIODevice::bytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_BytesWritten(ptr.Pointer(), C.longlong(bytes))
|
|
}
|
|
}
|
|
|
|
//export callbackQIODevice_CanReadLine
|
|
func callbackQIODevice_CanReadLine(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QIODevice::canReadLine")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canReadLine"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).CanReadLineDefault()))
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectCanReadLine(f func() bool) {
|
|
defer qt.Recovering("connect QIODevice::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canReadLine", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectCanReadLine() {
|
|
defer qt.Recovering("disconnect QIODevice::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canReadLine")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) CanReadLine() bool {
|
|
defer qt.Recovering("QIODevice::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_CanReadLine(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) CanReadLineDefault() bool {
|
|
defer qt.Recovering("QIODevice::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_CanReadLineDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIODevice_Close
|
|
func callbackQIODevice_Close(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QIODevice::close")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQIODeviceFromPointer(ptr).CloseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectClose(f func()) {
|
|
defer qt.Recovering("connect QIODevice::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "close", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectClose() {
|
|
defer qt.Recovering("disconnect QIODevice::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "close")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) Close() {
|
|
defer qt.Recovering("QIODevice::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_Close(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) CloseDefault() {
|
|
defer qt.Recovering("QIODevice::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_CloseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ErrorString() string {
|
|
defer qt.Recovering("QIODevice::errorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QIODevice_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QIODevice) IsOpen() bool {
|
|
defer qt.Recovering("QIODevice::isOpen")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_IsOpen(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) IsReadable() bool {
|
|
defer qt.Recovering("QIODevice::isReadable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_IsReadable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIODevice_IsSequential
|
|
func callbackQIODevice_IsSequential(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QIODevice::isSequential")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "isSequential"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).IsSequentialDefault()))
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectIsSequential(f func() bool) {
|
|
defer qt.Recovering("connect QIODevice::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "isSequential", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectIsSequential() {
|
|
defer qt.Recovering("disconnect QIODevice::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "isSequential")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) IsSequential() bool {
|
|
defer qt.Recovering("QIODevice::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_IsSequential(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) IsSequentialDefault() bool {
|
|
defer qt.Recovering("QIODevice::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_IsSequentialDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) IsTextModeEnabled() bool {
|
|
defer qt.Recovering("QIODevice::isTextModeEnabled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_IsTextModeEnabled(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) IsWritable() bool {
|
|
defer qt.Recovering("QIODevice::isWritable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_IsWritable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIODevice_Open
|
|
func callbackQIODevice_Open(ptr unsafe.Pointer, ptrName *C.char, mode C.int) C.int {
|
|
defer qt.Recovering("callback QIODevice::open")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "open"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(QIODevice__OpenModeFlag) bool)(QIODevice__OpenModeFlag(mode))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).OpenDefault(QIODevice__OpenModeFlag(mode))))
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectOpen(f func(mode QIODevice__OpenModeFlag) bool) {
|
|
defer qt.Recovering("connect QIODevice::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "open", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectOpen() {
|
|
defer qt.Recovering("disconnect QIODevice::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "open")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) Open(mode QIODevice__OpenModeFlag) bool {
|
|
defer qt.Recovering("QIODevice::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_Open(ptr.Pointer(), C.int(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) OpenDefault(mode QIODevice__OpenModeFlag) bool {
|
|
defer qt.Recovering("QIODevice::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_OpenDefault(ptr.Pointer(), C.int(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) OpenMode() QIODevice__OpenModeFlag {
|
|
defer qt.Recovering("QIODevice::openMode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QIODevice__OpenModeFlag(C.QIODevice_OpenMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIODevice) Peek2(maxSize int64) string {
|
|
defer qt.Recovering("QIODevice::peek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QIODevice_Peek2(ptr.Pointer(), C.longlong(maxSize)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QIODevice) Peek(data string, maxSize int64) int64 {
|
|
defer qt.Recovering("QIODevice::peek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_Peek(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQIODevice_Pos
|
|
func callbackQIODevice_Pos(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QIODevice::pos")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pos"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQIODeviceFromPointer(ptr).PosDefault())
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectPos(f func() int64) {
|
|
defer qt.Recovering("connect QIODevice::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pos", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectPos() {
|
|
defer qt.Recovering("disconnect QIODevice::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pos")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) Pos() int64 {
|
|
defer qt.Recovering("QIODevice::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_Pos(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIODevice) PosDefault() int64 {
|
|
defer qt.Recovering("QIODevice::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_PosDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIODevice) Read2(maxSize int64) string {
|
|
defer qt.Recovering("QIODevice::read")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QIODevice_Read2(ptr.Pointer(), C.longlong(maxSize)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QIODevice) Read(data string, maxSize int64) int64 {
|
|
defer qt.Recovering("QIODevice::read")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_Read(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIODevice) ReadAll() string {
|
|
defer qt.Recovering("QIODevice::readAll")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QIODevice_ReadAll(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQIODevice_ReadChannelFinished
|
|
func callbackQIODevice_ReadChannelFinished(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QIODevice::readChannelFinished")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "readChannelFinished"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectReadChannelFinished(f func()) {
|
|
defer qt.Recovering("connect QIODevice::readChannelFinished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_ConnectReadChannelFinished(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "readChannelFinished", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectReadChannelFinished() {
|
|
defer qt.Recovering("disconnect QIODevice::readChannelFinished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_DisconnectReadChannelFinished(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "readChannelFinished")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ReadChannelFinished() {
|
|
defer qt.Recovering("QIODevice::readChannelFinished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_ReadChannelFinished(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ReadLine2(maxSize int64) string {
|
|
defer qt.Recovering("QIODevice::readLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QIODevice_ReadLine2(ptr.Pointer(), C.longlong(maxSize)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QIODevice) ReadLine(data string, maxSize int64) int64 {
|
|
defer qt.Recovering("QIODevice::readLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_ReadLine(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQIODevice_ReadLineData
|
|
func callbackQIODevice_ReadLineData(ptr unsafe.Pointer, ptrName *C.char, data *C.char, maxSize C.longlong) C.longlong {
|
|
defer qt.Recovering("callback QIODevice::readLineData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "readLineData"); signal != nil {
|
|
return C.longlong(signal.(func(string, int64) int64)(C.GoString(data), int64(maxSize)))
|
|
}
|
|
|
|
return C.longlong(NewQIODeviceFromPointer(ptr).ReadLineDataDefault(C.GoString(data), int64(maxSize)))
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectReadLineData(f func(data string, maxSize int64) int64) {
|
|
defer qt.Recovering("connect QIODevice::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "readLineData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectReadLineData() {
|
|
defer qt.Recovering("disconnect QIODevice::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "readLineData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ReadLineData(data string, maxSize int64) int64 {
|
|
defer qt.Recovering("QIODevice::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_ReadLineData(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIODevice) ReadLineDataDefault(data string, maxSize int64) int64 {
|
|
defer qt.Recovering("QIODevice::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_ReadLineDataDefault(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQIODevice_ReadyRead
|
|
func callbackQIODevice_ReadyRead(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QIODevice::readyRead")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "readyRead"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectReadyRead(f func()) {
|
|
defer qt.Recovering("connect QIODevice::readyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_ConnectReadyRead(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "readyRead", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectReadyRead() {
|
|
defer qt.Recovering("disconnect QIODevice::readyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_DisconnectReadyRead(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "readyRead")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ReadyRead() {
|
|
defer qt.Recovering("QIODevice::readyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_ReadyRead(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQIODevice_Reset
|
|
func callbackQIODevice_Reset(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QIODevice::reset")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "reset"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).ResetDefault()))
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectReset(f func() bool) {
|
|
defer qt.Recovering("connect QIODevice::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "reset", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectReset() {
|
|
defer qt.Recovering("disconnect QIODevice::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "reset")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) Reset() bool {
|
|
defer qt.Recovering("QIODevice::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_Reset(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) ResetDefault() bool {
|
|
defer qt.Recovering("QIODevice::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_ResetDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIODevice_Seek
|
|
func callbackQIODevice_Seek(ptr unsafe.Pointer, ptrName *C.char, pos C.longlong) C.int {
|
|
defer qt.Recovering("callback QIODevice::seek")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "seek"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int64) bool)(int64(pos))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).SeekDefault(int64(pos))))
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectSeek(f func(pos int64) bool) {
|
|
defer qt.Recovering("connect QIODevice::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "seek", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectSeek() {
|
|
defer qt.Recovering("disconnect QIODevice::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "seek")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) Seek(pos int64) bool {
|
|
defer qt.Recovering("QIODevice::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_Seek(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) SeekDefault(pos int64) bool {
|
|
defer qt.Recovering("QIODevice::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_SeekDefault(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) SetErrorString(str string) {
|
|
defer qt.Recovering("QIODevice::setErrorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_SetErrorString(ptr.Pointer(), C.CString(str))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) SetOpenMode(openMode QIODevice__OpenModeFlag) {
|
|
defer qt.Recovering("QIODevice::setOpenMode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_SetOpenMode(ptr.Pointer(), C.int(openMode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) SetTextModeEnabled(enabled bool) {
|
|
defer qt.Recovering("QIODevice::setTextModeEnabled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_SetTextModeEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(enabled)))
|
|
}
|
|
}
|
|
|
|
//export callbackQIODevice_Size
|
|
func callbackQIODevice_Size(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QIODevice::size")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "size"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQIODeviceFromPointer(ptr).SizeDefault())
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectSize(f func() int64) {
|
|
defer qt.Recovering("connect QIODevice::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "size", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectSize() {
|
|
defer qt.Recovering("disconnect QIODevice::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "size")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) Size() int64 {
|
|
defer qt.Recovering("QIODevice::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIODevice) SizeDefault() int64 {
|
|
defer qt.Recovering("QIODevice::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_SizeDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIODevice) UngetChar(c string) {
|
|
defer qt.Recovering("QIODevice::ungetChar")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_UngetChar(ptr.Pointer(), C.CString(c))
|
|
}
|
|
}
|
|
|
|
//export callbackQIODevice_WaitForBytesWritten
|
|
func callbackQIODevice_WaitForBytesWritten(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) C.int {
|
|
defer qt.Recovering("callback QIODevice::waitForBytesWritten")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "waitForBytesWritten"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(msecs))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).WaitForBytesWrittenDefault(int(msecs))))
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectWaitForBytesWritten(f func(msecs int) bool) {
|
|
defer qt.Recovering("connect QIODevice::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "waitForBytesWritten", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectWaitForBytesWritten() {
|
|
defer qt.Recovering("disconnect QIODevice::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "waitForBytesWritten")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) WaitForBytesWritten(msecs int) bool {
|
|
defer qt.Recovering("QIODevice::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_WaitForBytesWritten(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) WaitForBytesWrittenDefault(msecs int) bool {
|
|
defer qt.Recovering("QIODevice::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_WaitForBytesWrittenDefault(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIODevice_WaitForReadyRead
|
|
func callbackQIODevice_WaitForReadyRead(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) C.int {
|
|
defer qt.Recovering("callback QIODevice::waitForReadyRead")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "waitForReadyRead"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(msecs))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).WaitForReadyReadDefault(int(msecs))))
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectWaitForReadyRead(f func(msecs int) bool) {
|
|
defer qt.Recovering("connect QIODevice::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "waitForReadyRead", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectWaitForReadyRead() {
|
|
defer qt.Recovering("disconnect QIODevice::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "waitForReadyRead")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) WaitForReadyRead(msecs int) bool {
|
|
defer qt.Recovering("QIODevice::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_WaitForReadyRead(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) WaitForReadyReadDefault(msecs int) bool {
|
|
defer qt.Recovering("QIODevice::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_WaitForReadyReadDefault(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) Write3(byteArray string) int64 {
|
|
defer qt.Recovering("QIODevice::write")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_Write3(ptr.Pointer(), C.CString(byteArray)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIODevice) Write2(data string) int64 {
|
|
defer qt.Recovering("QIODevice::write")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_Write2(ptr.Pointer(), C.CString(data)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIODevice) Write(data string, maxSize int64) int64 {
|
|
defer qt.Recovering("QIODevice::write")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_Write(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQIODevice_WriteData
|
|
func callbackQIODevice_WriteData(ptr unsafe.Pointer, ptrName *C.char, data *C.char, maxSize C.longlong) C.longlong {
|
|
defer qt.Recovering("callback QIODevice::writeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "writeData"); signal != nil {
|
|
return C.longlong(signal.(func(string, int64) int64)(C.GoString(data), int64(maxSize)))
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectWriteData(f func(data string, maxSize int64) int64) {
|
|
defer qt.Recovering("connect QIODevice::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "writeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectWriteData(data string, maxSize int64) {
|
|
defer qt.Recovering("disconnect QIODevice::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "writeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) WriteData(data string, maxSize int64) int64 {
|
|
defer qt.Recovering("QIODevice::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QIODevice_WriteData(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIODevice) DestroyQIODevice() {
|
|
defer qt.Recovering("QIODevice::~QIODevice")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QIODevice_DestroyQIODevice(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQIODevice_TimerEvent
|
|
func callbackQIODevice_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QIODevice::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQIODeviceFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QIODevice::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QIODevice::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QIODevice::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QIODevice::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQIODevice_ChildEvent
|
|
func callbackQIODevice_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QIODevice::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQIODeviceFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QIODevice::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QIODevice::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QIODevice::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QIODevice::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQIODevice_ConnectNotify
|
|
func callbackQIODevice_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QIODevice::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQIODeviceFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QIODevice::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QIODevice::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QIODevice::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QIODevice::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQIODevice_CustomEvent
|
|
func callbackQIODevice_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QIODevice::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQIODeviceFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QIODevice::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QIODevice::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QIODevice::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QIODevice::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQIODevice_DeleteLater
|
|
func callbackQIODevice_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QIODevice::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQIODeviceFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QIODevice::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QIODevice::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DeleteLater() {
|
|
defer qt.Recovering("QIODevice::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QIODevice_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DeleteLaterDefault() {
|
|
defer qt.Recovering("QIODevice::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QIODevice_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQIODevice_DisconnectNotify
|
|
func callbackQIODevice_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QIODevice::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQIODeviceFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QIODevice::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QIODevice::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QIODevice::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QIODevice::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIODevice_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQIODevice_Event
|
|
func callbackQIODevice_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIODevice::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QIODevice::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QIODevice::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QIODevice::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QIODevice::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIODevice_EventFilter
|
|
func callbackQIODevice_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIODevice::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QIODevice::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QIODevice::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QIODevice::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIODevice) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QIODevice::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIODevice_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIODevice_MetaObject
|
|
func callbackQIODevice_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIODevice::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQIODeviceFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QIODevice) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QIODevice::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QIODevice::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIODevice) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QIODevice::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QIODevice_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIODevice) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QIODevice::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QIODevice_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QIdentityProxyModel struct {
|
|
QAbstractProxyModel
|
|
}
|
|
|
|
type QIdentityProxyModel_ITF interface {
|
|
QAbstractProxyModel_ITF
|
|
QIdentityProxyModel_PTR() *QIdentityProxyModel
|
|
}
|
|
|
|
func (p *QIdentityProxyModel) QIdentityProxyModel_PTR() *QIdentityProxyModel {
|
|
return p
|
|
}
|
|
|
|
func (p *QIdentityProxyModel) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractProxyModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QIdentityProxyModel) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractProxyModel_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQIdentityProxyModel(ptr QIdentityProxyModel_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QIdentityProxyModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQIdentityProxyModelFromPointer(ptr unsafe.Pointer) *QIdentityProxyModel {
|
|
var n = new(QIdentityProxyModel)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQIdentityProxyModelFromPointer(ptr unsafe.Pointer) *QIdentityProxyModel {
|
|
var n = NewQIdentityProxyModelFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QIdentityProxyModel_") {
|
|
n.SetObjectName("QIdentityProxyModel_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQIdentityProxyModel(parent QObject_ITF) *QIdentityProxyModel {
|
|
defer qt.Recovering("QIdentityProxyModel::QIdentityProxyModel")
|
|
|
|
return newQIdentityProxyModelFromPointer(C.QIdentityProxyModel_NewQIdentityProxyModel(PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_ColumnCount
|
|
func callbackQIdentityProxyModel_ColumnCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::columnCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(NewQIdentityProxyModelFromPointer(ptr).ColumnCountDefault(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectColumnCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectColumnCount() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ColumnCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QIdentityProxyModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QIdentityProxyModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ColumnCountDefault(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QIdentityProxyModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QIdentityProxyModel_ColumnCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_DropMimeData
|
|
func callbackQIdentityProxyModel_DropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::dropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "dropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).DropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "dropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectDropMimeData() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "dropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_DropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_HeaderData
|
|
func callbackQIdentityProxyModel_HeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIdentityProxyModel::headerData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "headerData"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(int, Qt__Orientation, int) *QVariant)(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQIdentityProxyModelFromPointer(ptr).HeaderDataDefault(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectHeaderData(f func(section int, orientation Qt__Orientation, role int) *QVariant) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "headerData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectHeaderData() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "headerData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) HeaderData(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QIdentityProxyModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QIdentityProxyModel_HeaderData(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) HeaderDataDefault(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QIdentityProxyModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QIdentityProxyModel_HeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_Index
|
|
func callbackQIdentityProxyModel_Index(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIdentityProxyModel::index")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "index"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQIdentityProxyModelFromPointer(ptr).IndexDefault(int(row), int(column), NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "index", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectIndex() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "index")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QIdentityProxyModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QIdentityProxyModel_Index(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) IndexDefault(row int, column int, parent QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QIdentityProxyModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QIdentityProxyModel_IndexDefault(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_InsertColumns
|
|
func callbackQIdentityProxyModel_InsertColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::insertColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).InsertColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectInsertColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectInsertColumns() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) InsertColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_InsertColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) InsertColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_InsertColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_InsertRows
|
|
func callbackQIdentityProxyModel_InsertRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::insertRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).InsertRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectInsertRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectInsertRows() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) InsertRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_InsertRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) InsertRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_InsertRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_MapFromSource
|
|
func callbackQIdentityProxyModel_MapFromSource(ptr unsafe.Pointer, ptrName *C.char, sourceIndex unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIdentityProxyModel::mapFromSource")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapFromSource"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(sourceIndex)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQIdentityProxyModelFromPointer(ptr).MapFromSourceDefault(NewQModelIndexFromPointer(sourceIndex)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectMapFromSource(f func(sourceIndex *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::mapFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapFromSource", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectMapFromSource() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::mapFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapFromSource")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MapFromSource(sourceIndex QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QIdentityProxyModel::mapFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QIdentityProxyModel_MapFromSource(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MapFromSourceDefault(sourceIndex QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QIdentityProxyModel::mapFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QIdentityProxyModel_MapFromSourceDefault(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_MapSelectionFromSource
|
|
func callbackQIdentityProxyModel_MapSelectionFromSource(ptr unsafe.Pointer, ptrName *C.char, selection unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIdentityProxyModel::mapSelectionFromSource")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapSelectionFromSource"); signal != nil {
|
|
return PointerFromQItemSelection(signal.(func(*QItemSelection) *QItemSelection)(NewQItemSelectionFromPointer(selection)))
|
|
}
|
|
|
|
return PointerFromQItemSelection(NewQIdentityProxyModelFromPointer(ptr).MapSelectionFromSourceDefault(NewQItemSelectionFromPointer(selection)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectMapSelectionFromSource(f func(selection *QItemSelection) *QItemSelection) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::mapSelectionFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapSelectionFromSource", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectMapSelectionFromSource() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::mapSelectionFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapSelectionFromSource")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MapSelectionFromSource(selection QItemSelection_ITF) *QItemSelection {
|
|
defer qt.Recovering("QIdentityProxyModel::mapSelectionFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QIdentityProxyModel_MapSelectionFromSource(ptr.Pointer(), PointerFromQItemSelection(selection)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MapSelectionFromSourceDefault(selection QItemSelection_ITF) *QItemSelection {
|
|
defer qt.Recovering("QIdentityProxyModel::mapSelectionFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QIdentityProxyModel_MapSelectionFromSourceDefault(ptr.Pointer(), PointerFromQItemSelection(selection)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_MapSelectionToSource
|
|
func callbackQIdentityProxyModel_MapSelectionToSource(ptr unsafe.Pointer, ptrName *C.char, selection unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIdentityProxyModel::mapSelectionToSource")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapSelectionToSource"); signal != nil {
|
|
return PointerFromQItemSelection(signal.(func(*QItemSelection) *QItemSelection)(NewQItemSelectionFromPointer(selection)))
|
|
}
|
|
|
|
return PointerFromQItemSelection(NewQIdentityProxyModelFromPointer(ptr).MapSelectionToSourceDefault(NewQItemSelectionFromPointer(selection)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectMapSelectionToSource(f func(selection *QItemSelection) *QItemSelection) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::mapSelectionToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapSelectionToSource", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectMapSelectionToSource() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::mapSelectionToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapSelectionToSource")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MapSelectionToSource(selection QItemSelection_ITF) *QItemSelection {
|
|
defer qt.Recovering("QIdentityProxyModel::mapSelectionToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QIdentityProxyModel_MapSelectionToSource(ptr.Pointer(), PointerFromQItemSelection(selection)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MapSelectionToSourceDefault(selection QItemSelection_ITF) *QItemSelection {
|
|
defer qt.Recovering("QIdentityProxyModel::mapSelectionToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QIdentityProxyModel_MapSelectionToSourceDefault(ptr.Pointer(), PointerFromQItemSelection(selection)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_MapToSource
|
|
func callbackQIdentityProxyModel_MapToSource(ptr unsafe.Pointer, ptrName *C.char, proxyIndex unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIdentityProxyModel::mapToSource")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapToSource"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(proxyIndex)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQIdentityProxyModelFromPointer(ptr).MapToSourceDefault(NewQModelIndexFromPointer(proxyIndex)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectMapToSource(f func(proxyIndex *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::mapToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapToSource", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectMapToSource() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::mapToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapToSource")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MapToSource(proxyIndex QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QIdentityProxyModel::mapToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QIdentityProxyModel_MapToSource(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MapToSourceDefault(proxyIndex QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QIdentityProxyModel::mapToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QIdentityProxyModel_MapToSourceDefault(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_Parent
|
|
func callbackQIdentityProxyModel_Parent(ptr unsafe.Pointer, ptrName *C.char, child unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIdentityProxyModel::parent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "parent"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(child)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQIdentityProxyModelFromPointer(ptr).ParentDefault(NewQModelIndexFromPointer(child)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectParent(f func(child *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "parent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectParent() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "parent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) Parent(child QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QIdentityProxyModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QIdentityProxyModel_Parent(ptr.Pointer(), PointerFromQModelIndex(child)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ParentDefault(child QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QIdentityProxyModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QIdentityProxyModel_ParentDefault(ptr.Pointer(), PointerFromQModelIndex(child)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_RemoveColumns
|
|
func callbackQIdentityProxyModel_RemoveColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::removeColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).RemoveColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectRemoveColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectRemoveColumns() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) RemoveColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_RemoveColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) RemoveColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_RemoveColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_RemoveRows
|
|
func callbackQIdentityProxyModel_RemoveRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::removeRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).RemoveRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectRemoveRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectRemoveRows() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) RemoveRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_RemoveRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) RemoveRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_RemoveRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_RowCount
|
|
func callbackQIdentityProxyModel_RowCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::rowCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(NewQIdentityProxyModelFromPointer(ptr).RowCountDefault(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectRowCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectRowCount() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) RowCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QIdentityProxyModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QIdentityProxyModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) RowCountDefault(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QIdentityProxyModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QIdentityProxyModel_RowCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_SetSourceModel
|
|
func callbackQIdentityProxyModel_SetSourceModel(ptr unsafe.Pointer, ptrName *C.char, newSourceModel unsafe.Pointer) {
|
|
defer qt.Recovering("callback QIdentityProxyModel::setSourceModel")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setSourceModel"); signal != nil {
|
|
signal.(func(*QAbstractItemModel))(NewQAbstractItemModelFromPointer(newSourceModel))
|
|
} else {
|
|
NewQIdentityProxyModelFromPointer(ptr).SetSourceModelDefault(NewQAbstractItemModelFromPointer(newSourceModel))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectSetSourceModel(f func(newSourceModel *QAbstractItemModel)) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::setSourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setSourceModel", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectSetSourceModel() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::setSourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setSourceModel")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SetSourceModel(newSourceModel QAbstractItemModel_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::setSourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_SetSourceModel(ptr.Pointer(), PointerFromQAbstractItemModel(newSourceModel))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SetSourceModelDefault(newSourceModel QAbstractItemModel_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::setSourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_SetSourceModelDefault(ptr.Pointer(), PointerFromQAbstractItemModel(newSourceModel))
|
|
}
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_Sibling
|
|
func callbackQIdentityProxyModel_Sibling(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, idx unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIdentityProxyModel::sibling")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sibling"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(idx)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQIdentityProxyModelFromPointer(ptr).SiblingDefault(int(row), int(column), NewQModelIndexFromPointer(idx)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectSibling(f func(row int, column int, idx *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sibling", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectSibling() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sibling")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) Sibling(row int, column int, idx QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QIdentityProxyModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QIdentityProxyModel_Sibling(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SiblingDefault(row int, column int, idx QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QIdentityProxyModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QIdentityProxyModel_SiblingDefault(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DestroyQIdentityProxyModel() {
|
|
defer qt.Recovering("QIdentityProxyModel::~QIdentityProxyModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QIdentityProxyModel_DestroyQIdentityProxyModel(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_Buddy
|
|
func callbackQIdentityProxyModel_Buddy(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIdentityProxyModel::buddy")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "buddy"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQIdentityProxyModelFromPointer(ptr).BuddyDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectBuddy(f func(index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "buddy", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectBuddy() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "buddy")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) Buddy(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QIdentityProxyModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QIdentityProxyModel_Buddy(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) BuddyDefault(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QIdentityProxyModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QIdentityProxyModel_BuddyDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_CanDropMimeData
|
|
func callbackQIdentityProxyModel_CanDropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::canDropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canDropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).CanDropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectCanDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canDropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectCanDropMimeData() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canDropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) CanDropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_CanDropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) CanDropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_CanDropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_CanFetchMore
|
|
func callbackQIdentityProxyModel_CanFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::canFetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canFetchMore"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).CanFetchMoreDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectCanFetchMore(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canFetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectCanFetchMore() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canFetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) CanFetchMore(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_CanFetchMore(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) CanFetchMoreDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_CanFetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_Data
|
|
func callbackQIdentityProxyModel_Data(ptr unsafe.Pointer, ptrName *C.char, proxyIndex unsafe.Pointer, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIdentityProxyModel::data")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "data"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(*QModelIndex, int) *QVariant)(NewQModelIndexFromPointer(proxyIndex), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQIdentityProxyModelFromPointer(ptr).DataDefault(NewQModelIndexFromPointer(proxyIndex), int(role)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectData(f func(proxyIndex *QModelIndex, role int) *QVariant) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "data", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectData() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "data")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) Data(proxyIndex QModelIndex_ITF, role int) *QVariant {
|
|
defer qt.Recovering("QIdentityProxyModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QIdentityProxyModel_Data(ptr.Pointer(), PointerFromQModelIndex(proxyIndex), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DataDefault(proxyIndex QModelIndex_ITF, role int) *QVariant {
|
|
defer qt.Recovering("QIdentityProxyModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QIdentityProxyModel_DataDefault(ptr.Pointer(), PointerFromQModelIndex(proxyIndex), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_FetchMore
|
|
func callbackQIdentityProxyModel_FetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
|
|
defer qt.Recovering("callback QIdentityProxyModel::fetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
|
|
signal.(func(*QModelIndex))(NewQModelIndexFromPointer(parent))
|
|
} else {
|
|
NewQIdentityProxyModelFromPointer(ptr).FetchMoreDefault(NewQModelIndexFromPointer(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectFetchMore(f func(parent *QModelIndex)) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectFetchMore() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) FetchMore(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_FetchMore(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) FetchMoreDefault(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_FetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_Flags
|
|
func callbackQIdentityProxyModel_Flags(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::flags")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "flags"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) Qt__ItemFlag)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return C.int(NewQIdentityProxyModelFromPointer(ptr).FlagsDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectFlags(f func(index *QModelIndex) Qt__ItemFlag) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "flags", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectFlags() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "flags")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QIdentityProxyModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QIdentityProxyModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) FlagsDefault(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QIdentityProxyModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QIdentityProxyModel_FlagsDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_HasChildren
|
|
func callbackQIdentityProxyModel_HasChildren(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::hasChildren")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "hasChildren"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).HasChildrenDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectHasChildren(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "hasChildren", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectHasChildren() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "hasChildren")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) HasChildren(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_HasChildren(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) HasChildrenDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_HasChildrenDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_MimeTypes
|
|
func callbackQIdentityProxyModel_MimeTypes(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QIdentityProxyModel::mimeTypes")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mimeTypes"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(NewQIdentityProxyModelFromPointer(ptr).MimeTypesDefault(), "|"))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectMimeTypes(f func() []string) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mimeTypes", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectMimeTypes() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mimeTypes")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MimeTypes() []string {
|
|
defer qt.Recovering("QIdentityProxyModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QIdentityProxyModel_MimeTypes(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MimeTypesDefault() []string {
|
|
defer qt.Recovering("QIdentityProxyModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QIdentityProxyModel_MimeTypesDefault(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_ResetInternalData
|
|
func callbackQIdentityProxyModel_ResetInternalData(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QIdentityProxyModel::resetInternalData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resetInternalData"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQIdentityProxyModelFromPointer(ptr).ResetInternalDataDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectResetInternalData(f func()) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resetInternalData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectResetInternalData() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resetInternalData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ResetInternalData() {
|
|
defer qt.Recovering("QIdentityProxyModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_ResetInternalData(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ResetInternalDataDefault() {
|
|
defer qt.Recovering("QIdentityProxyModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_ResetInternalDataDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_Revert
|
|
func callbackQIdentityProxyModel_Revert(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QIdentityProxyModel::revert")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQIdentityProxyModelFromPointer(ptr).RevertDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectRevert(f func()) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "revert", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectRevert() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "revert")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) Revert() {
|
|
defer qt.Recovering("QIdentityProxyModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_Revert(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) RevertDefault() {
|
|
defer qt.Recovering("QIdentityProxyModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_RevertDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_SetData
|
|
func callbackQIdentityProxyModel_SetData(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::setData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, *QVariant, int) bool)(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).SetDataDefault(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectSetData(f func(index *QModelIndex, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectSetData() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SetData(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_SetData(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SetDataDefault(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_SetDataDefault(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_SetHeaderData
|
|
func callbackQIdentityProxyModel_SetHeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::setHeaderData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setHeaderData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, Qt__Orientation, *QVariant, int) bool)(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).SetHeaderDataDefault(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectSetHeaderData(f func(section int, orientation Qt__Orientation, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setHeaderData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectSetHeaderData() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setHeaderData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SetHeaderData(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_SetHeaderData(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SetHeaderDataDefault(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_SetHeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_Sort
|
|
func callbackQIdentityProxyModel_Sort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
|
|
defer qt.Recovering("callback QIdentityProxyModel::sort")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
|
|
signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
|
|
} else {
|
|
NewQIdentityProxyModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sort", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectSort() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sort")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) Sort(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QIdentityProxyModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SortDefault(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QIdentityProxyModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_Span
|
|
func callbackQIdentityProxyModel_Span(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIdentityProxyModel::span")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "span"); signal != nil {
|
|
return PointerFromQSize(signal.(func(*QModelIndex) *QSize)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQSize(NewQIdentityProxyModelFromPointer(ptr).SpanDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectSpan(f func(index *QModelIndex) *QSize) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "span", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectSpan() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "span")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) Span(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QIdentityProxyModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QIdentityProxyModel_Span(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SpanDefault(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QIdentityProxyModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QIdentityProxyModel_SpanDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_Submit
|
|
func callbackQIdentityProxyModel_Submit(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::submit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "submit"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).SubmitDefault()))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectSubmit(f func() bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "submit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectSubmit() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "submit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) Submit() bool {
|
|
defer qt.Recovering("QIdentityProxyModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_Submit(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SubmitDefault() bool {
|
|
defer qt.Recovering("QIdentityProxyModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_SubmitDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_SupportedDragActions
|
|
func callbackQIdentityProxyModel_SupportedDragActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::supportedDragActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDragActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQIdentityProxyModelFromPointer(ptr).SupportedDragActionsDefault())
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectSupportedDragActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDragActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectSupportedDragActions() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDragActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SupportedDragActions() Qt__DropAction {
|
|
defer qt.Recovering("QIdentityProxyModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QIdentityProxyModel_SupportedDragActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SupportedDragActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QIdentityProxyModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QIdentityProxyModel_SupportedDragActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_SupportedDropActions
|
|
func callbackQIdentityProxyModel_SupportedDropActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::supportedDropActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDropActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQIdentityProxyModelFromPointer(ptr).SupportedDropActionsDefault())
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectSupportedDropActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDropActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectSupportedDropActions() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDropActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SupportedDropActions() Qt__DropAction {
|
|
defer qt.Recovering("QIdentityProxyModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QIdentityProxyModel_SupportedDropActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) SupportedDropActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QIdentityProxyModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QIdentityProxyModel_SupportedDropActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_MoveColumns
|
|
func callbackQIdentityProxyModel_MoveColumns(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceColumn C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::moveColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).MoveColumnsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectMoveColumns(f func(sourceParent *QModelIndex, sourceColumn int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectMoveColumns() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MoveColumns(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_MoveColumns(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MoveColumnsDefault(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_MoveColumnsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_MoveRows
|
|
func callbackQIdentityProxyModel_MoveRows(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceRow C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::moveRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).MoveRowsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectMoveRows(f func(sourceParent *QModelIndex, sourceRow int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectMoveRows() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MoveRows(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_MoveRows(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MoveRowsDefault(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_MoveRowsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_TimerEvent
|
|
func callbackQIdentityProxyModel_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QIdentityProxyModel::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQIdentityProxyModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_ChildEvent
|
|
func callbackQIdentityProxyModel_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QIdentityProxyModel::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQIdentityProxyModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_ConnectNotify
|
|
func callbackQIdentityProxyModel_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QIdentityProxyModel::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQIdentityProxyModelFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_CustomEvent
|
|
func callbackQIdentityProxyModel_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QIdentityProxyModel::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQIdentityProxyModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_DeleteLater
|
|
func callbackQIdentityProxyModel_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QIdentityProxyModel::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQIdentityProxyModelFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DeleteLater() {
|
|
defer qt.Recovering("QIdentityProxyModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QIdentityProxyModel_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DeleteLaterDefault() {
|
|
defer qt.Recovering("QIdentityProxyModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QIdentityProxyModel_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_DisconnectNotify
|
|
func callbackQIdentityProxyModel_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QIdentityProxyModel::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQIdentityProxyModelFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QIdentityProxyModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QIdentityProxyModel_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_Event
|
|
func callbackQIdentityProxyModel_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_EventFilter
|
|
func callbackQIdentityProxyModel_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QIdentityProxyModel::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQIdentityProxyModelFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QIdentityProxyModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QIdentityProxyModel_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQIdentityProxyModel_MetaObject
|
|
func callbackQIdentityProxyModel_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QIdentityProxyModel::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQIdentityProxyModelFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QIdentityProxyModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QIdentityProxyModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QIdentityProxyModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QIdentityProxyModel_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QIdentityProxyModel) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QIdentityProxyModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QIdentityProxyModel_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QItemSelection struct {
|
|
QList
|
|
}
|
|
|
|
type QItemSelection_ITF interface {
|
|
QList_ITF
|
|
QItemSelection_PTR() *QItemSelection
|
|
}
|
|
|
|
func (p *QItemSelection) QItemSelection_PTR() *QItemSelection {
|
|
return p
|
|
}
|
|
|
|
func (p *QItemSelection) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QList_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QItemSelection) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QList_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQItemSelection(ptr QItemSelection_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QItemSelection_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQItemSelectionFromPointer(ptr unsafe.Pointer) *QItemSelection {
|
|
var n = new(QItemSelection)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQItemSelectionFromPointer(ptr unsafe.Pointer) *QItemSelection {
|
|
var n = NewQItemSelectionFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQItemSelection() *QItemSelection {
|
|
defer qt.Recovering("QItemSelection::QItemSelection")
|
|
|
|
return newQItemSelectionFromPointer(C.QItemSelection_NewQItemSelection())
|
|
}
|
|
|
|
func NewQItemSelection2(topLeft QModelIndex_ITF, bottomRight QModelIndex_ITF) *QItemSelection {
|
|
defer qt.Recovering("QItemSelection::QItemSelection")
|
|
|
|
return newQItemSelectionFromPointer(C.QItemSelection_NewQItemSelection2(PointerFromQModelIndex(topLeft), PointerFromQModelIndex(bottomRight)))
|
|
}
|
|
|
|
func (ptr *QItemSelection) Contains(index QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QItemSelection::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelection_Contains(ptr.Pointer(), PointerFromQModelIndex(index)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QItemSelection) Merge(other QItemSelection_ITF, command QItemSelectionModel__SelectionFlag) {
|
|
defer qt.Recovering("QItemSelection::merge")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelection_Merge(ptr.Pointer(), PointerFromQItemSelection(other), C.int(command))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelection) Select(topLeft QModelIndex_ITF, bottomRight QModelIndex_ITF) {
|
|
defer qt.Recovering("QItemSelection::select")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelection_Select(ptr.Pointer(), PointerFromQModelIndex(topLeft), PointerFromQModelIndex(bottomRight))
|
|
}
|
|
}
|
|
|
|
func QItemSelection_Split(ran QItemSelectionRange_ITF, other QItemSelectionRange_ITF, result QItemSelection_ITF) {
|
|
defer qt.Recovering("QItemSelection::split")
|
|
|
|
C.QItemSelection_QItemSelection_Split(PointerFromQItemSelectionRange(ran), PointerFromQItemSelectionRange(other), PointerFromQItemSelection(result))
|
|
}
|
|
|
|
func (ptr *QItemSelection) Split(ran QItemSelectionRange_ITF, other QItemSelectionRange_ITF, result QItemSelection_ITF) {
|
|
defer qt.Recovering("QItemSelection::split")
|
|
|
|
C.QItemSelection_QItemSelection_Split(PointerFromQItemSelectionRange(ran), PointerFromQItemSelectionRange(other), PointerFromQItemSelection(result))
|
|
}
|
|
|
|
//QItemSelectionModel::SelectionFlag
|
|
type QItemSelectionModel__SelectionFlag int64
|
|
|
|
const (
|
|
QItemSelectionModel__NoUpdate = QItemSelectionModel__SelectionFlag(0x0000)
|
|
QItemSelectionModel__Clear = QItemSelectionModel__SelectionFlag(0x0001)
|
|
QItemSelectionModel__Select = QItemSelectionModel__SelectionFlag(0x0002)
|
|
QItemSelectionModel__Deselect = QItemSelectionModel__SelectionFlag(0x0004)
|
|
QItemSelectionModel__Toggle = QItemSelectionModel__SelectionFlag(0x0008)
|
|
QItemSelectionModel__Current = QItemSelectionModel__SelectionFlag(0x0010)
|
|
QItemSelectionModel__Rows = QItemSelectionModel__SelectionFlag(0x0020)
|
|
QItemSelectionModel__Columns = QItemSelectionModel__SelectionFlag(0x0040)
|
|
QItemSelectionModel__SelectCurrent = QItemSelectionModel__SelectionFlag(QItemSelectionModel__Select | QItemSelectionModel__Current)
|
|
QItemSelectionModel__ToggleCurrent = QItemSelectionModel__SelectionFlag(QItemSelectionModel__Toggle | QItemSelectionModel__Current)
|
|
QItemSelectionModel__ClearAndSelect = QItemSelectionModel__SelectionFlag(QItemSelectionModel__Clear | QItemSelectionModel__Select)
|
|
)
|
|
|
|
type QItemSelectionModel struct {
|
|
QObject
|
|
}
|
|
|
|
type QItemSelectionModel_ITF interface {
|
|
QObject_ITF
|
|
QItemSelectionModel_PTR() *QItemSelectionModel
|
|
}
|
|
|
|
func (p *QItemSelectionModel) QItemSelectionModel_PTR() *QItemSelectionModel {
|
|
return p
|
|
}
|
|
|
|
func (p *QItemSelectionModel) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QItemSelectionModel) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQItemSelectionModel(ptr QItemSelectionModel_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QItemSelectionModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQItemSelectionModelFromPointer(ptr unsafe.Pointer) *QItemSelectionModel {
|
|
var n = new(QItemSelectionModel)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQItemSelectionModelFromPointer(ptr unsafe.Pointer) *QItemSelectionModel {
|
|
var n = NewQItemSelectionModelFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QItemSelectionModel_") {
|
|
n.SetObjectName("QItemSelectionModel_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQItemSelectionModel(model QAbstractItemModel_ITF) *QItemSelectionModel {
|
|
defer qt.Recovering("QItemSelectionModel::QItemSelectionModel")
|
|
|
|
return newQItemSelectionModelFromPointer(C.QItemSelectionModel_NewQItemSelectionModel(PointerFromQAbstractItemModel(model)))
|
|
}
|
|
|
|
func NewQItemSelectionModel2(model QAbstractItemModel_ITF, parent QObject_ITF) *QItemSelectionModel {
|
|
defer qt.Recovering("QItemSelectionModel::QItemSelectionModel")
|
|
|
|
return newQItemSelectionModelFromPointer(C.QItemSelectionModel_NewQItemSelectionModel2(PointerFromQAbstractItemModel(model), PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_Clear
|
|
func callbackQItemSelectionModel_Clear(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QItemSelectionModel::clear")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "clear"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQItemSelectionModelFromPointer(ptr).ClearDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectClear(f func()) {
|
|
defer qt.Recovering("connect QItemSelectionModel::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "clear", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectClear() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "clear")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) Clear() {
|
|
defer qt.Recovering("QItemSelectionModel::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ClearDefault() {
|
|
defer qt.Recovering("QItemSelectionModel::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ClearDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_ClearCurrentIndex
|
|
func callbackQItemSelectionModel_ClearCurrentIndex(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QItemSelectionModel::clearCurrentIndex")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "clearCurrentIndex"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQItemSelectionModelFromPointer(ptr).ClearCurrentIndexDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectClearCurrentIndex(f func()) {
|
|
defer qt.Recovering("connect QItemSelectionModel::clearCurrentIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "clearCurrentIndex", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectClearCurrentIndex() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::clearCurrentIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "clearCurrentIndex")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ClearCurrentIndex() {
|
|
defer qt.Recovering("QItemSelectionModel::clearCurrentIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ClearCurrentIndex(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ClearCurrentIndexDefault() {
|
|
defer qt.Recovering("QItemSelectionModel::clearCurrentIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ClearCurrentIndexDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_ClearSelection
|
|
func callbackQItemSelectionModel_ClearSelection(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QItemSelectionModel::clearSelection")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "clearSelection"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectClearSelection(f func()) {
|
|
defer qt.Recovering("connect QItemSelectionModel::clearSelection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "clearSelection", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectClearSelection() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::clearSelection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "clearSelection")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ClearSelection() {
|
|
defer qt.Recovering("QItemSelectionModel::clearSelection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ClearSelection(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ColumnIntersectsSelection(column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QItemSelectionModel::columnIntersectsSelection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionModel_ColumnIntersectsSelection(ptr.Pointer(), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_CurrentChanged
|
|
func callbackQItemSelectionModel_CurrentChanged(ptr unsafe.Pointer, ptrName *C.char, current unsafe.Pointer, previous unsafe.Pointer) {
|
|
defer qt.Recovering("callback QItemSelectionModel::currentChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "currentChanged"); signal != nil {
|
|
signal.(func(*QModelIndex, *QModelIndex))(NewQModelIndexFromPointer(current), NewQModelIndexFromPointer(previous))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectCurrentChanged(f func(current *QModelIndex, previous *QModelIndex)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::currentChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ConnectCurrentChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "currentChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectCurrentChanged() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::currentChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_DisconnectCurrentChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "currentChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) CurrentChanged(current QModelIndex_ITF, previous QModelIndex_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::currentChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_CurrentChanged(ptr.Pointer(), PointerFromQModelIndex(current), PointerFromQModelIndex(previous))
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_CurrentColumnChanged
|
|
func callbackQItemSelectionModel_CurrentColumnChanged(ptr unsafe.Pointer, ptrName *C.char, current unsafe.Pointer, previous unsafe.Pointer) {
|
|
defer qt.Recovering("callback QItemSelectionModel::currentColumnChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "currentColumnChanged"); signal != nil {
|
|
signal.(func(*QModelIndex, *QModelIndex))(NewQModelIndexFromPointer(current), NewQModelIndexFromPointer(previous))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectCurrentColumnChanged(f func(current *QModelIndex, previous *QModelIndex)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::currentColumnChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ConnectCurrentColumnChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "currentColumnChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectCurrentColumnChanged() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::currentColumnChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_DisconnectCurrentColumnChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "currentColumnChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) CurrentColumnChanged(current QModelIndex_ITF, previous QModelIndex_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::currentColumnChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_CurrentColumnChanged(ptr.Pointer(), PointerFromQModelIndex(current), PointerFromQModelIndex(previous))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) CurrentIndex() *QModelIndex {
|
|
defer qt.Recovering("QItemSelectionModel::currentIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QItemSelectionModel_CurrentIndex(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_CurrentRowChanged
|
|
func callbackQItemSelectionModel_CurrentRowChanged(ptr unsafe.Pointer, ptrName *C.char, current unsafe.Pointer, previous unsafe.Pointer) {
|
|
defer qt.Recovering("callback QItemSelectionModel::currentRowChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "currentRowChanged"); signal != nil {
|
|
signal.(func(*QModelIndex, *QModelIndex))(NewQModelIndexFromPointer(current), NewQModelIndexFromPointer(previous))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectCurrentRowChanged(f func(current *QModelIndex, previous *QModelIndex)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::currentRowChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ConnectCurrentRowChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "currentRowChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectCurrentRowChanged() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::currentRowChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_DisconnectCurrentRowChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "currentRowChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) CurrentRowChanged(current QModelIndex_ITF, previous QModelIndex_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::currentRowChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_CurrentRowChanged(ptr.Pointer(), PointerFromQModelIndex(current), PointerFromQModelIndex(previous))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) EmitSelectionChanged(newSelection QItemSelection_ITF, oldSelection QItemSelection_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::emitSelectionChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_EmitSelectionChanged(ptr.Pointer(), PointerFromQItemSelection(newSelection), PointerFromQItemSelection(oldSelection))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) HasSelection() bool {
|
|
defer qt.Recovering("QItemSelectionModel::hasSelection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionModel_HasSelection(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) IsColumnSelected(column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QItemSelectionModel::isColumnSelected")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionModel_IsColumnSelected(ptr.Pointer(), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) IsRowSelected(row int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QItemSelectionModel::isRowSelected")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionModel_IsRowSelected(ptr.Pointer(), C.int(row), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) IsSelected(index QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QItemSelectionModel::isSelected")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionModel_IsSelected(ptr.Pointer(), PointerFromQModelIndex(index)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) Model2() *QAbstractItemModel {
|
|
defer qt.Recovering("QItemSelectionModel::model")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractItemModelFromPointer(C.QItemSelectionModel_Model2(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) Model() *QAbstractItemModel {
|
|
defer qt.Recovering("QItemSelectionModel::model")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractItemModelFromPointer(C.QItemSelectionModel_Model(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_ModelChanged
|
|
func callbackQItemSelectionModel_ModelChanged(ptr unsafe.Pointer, ptrName *C.char, model unsafe.Pointer) {
|
|
defer qt.Recovering("callback QItemSelectionModel::modelChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "modelChanged"); signal != nil {
|
|
signal.(func(*QAbstractItemModel))(NewQAbstractItemModelFromPointer(model))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectModelChanged(f func(model *QAbstractItemModel)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::modelChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ConnectModelChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "modelChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectModelChanged() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::modelChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_DisconnectModelChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "modelChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ModelChanged(model QAbstractItemModel_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::modelChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ModelChanged(ptr.Pointer(), PointerFromQAbstractItemModel(model))
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_Reset
|
|
func callbackQItemSelectionModel_Reset(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QItemSelectionModel::reset")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "reset"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQItemSelectionModelFromPointer(ptr).ResetDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectReset(f func()) {
|
|
defer qt.Recovering("connect QItemSelectionModel::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "reset", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectReset() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "reset")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) Reset() {
|
|
defer qt.Recovering("QItemSelectionModel::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_Reset(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ResetDefault() {
|
|
defer qt.Recovering("QItemSelectionModel::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ResetDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) RowIntersectsSelection(row int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QItemSelectionModel::rowIntersectsSelection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionModel_RowIntersectsSelection(ptr.Pointer(), C.int(row), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_Select2
|
|
func callbackQItemSelectionModel_Select2(ptr unsafe.Pointer, ptrName *C.char, selection unsafe.Pointer, command C.int) {
|
|
defer qt.Recovering("callback QItemSelectionModel::select")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "select2"); signal != nil {
|
|
signal.(func(*QItemSelection, QItemSelectionModel__SelectionFlag))(NewQItemSelectionFromPointer(selection), QItemSelectionModel__SelectionFlag(command))
|
|
} else {
|
|
NewQItemSelectionModelFromPointer(ptr).Select2Default(NewQItemSelectionFromPointer(selection), QItemSelectionModel__SelectionFlag(command))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectSelect2(f func(selection *QItemSelection, command QItemSelectionModel__SelectionFlag)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::select")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "select2", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectSelect2() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::select")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "select2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) Select2(selection QItemSelection_ITF, command QItemSelectionModel__SelectionFlag) {
|
|
defer qt.Recovering("QItemSelectionModel::select")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_Select2(ptr.Pointer(), PointerFromQItemSelection(selection), C.int(command))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) Select2Default(selection QItemSelection_ITF, command QItemSelectionModel__SelectionFlag) {
|
|
defer qt.Recovering("QItemSelectionModel::select")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_Select2Default(ptr.Pointer(), PointerFromQItemSelection(selection), C.int(command))
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_Select
|
|
func callbackQItemSelectionModel_Select(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, command C.int) {
|
|
defer qt.Recovering("callback QItemSelectionModel::select")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "select"); signal != nil {
|
|
signal.(func(*QModelIndex, QItemSelectionModel__SelectionFlag))(NewQModelIndexFromPointer(index), QItemSelectionModel__SelectionFlag(command))
|
|
} else {
|
|
NewQItemSelectionModelFromPointer(ptr).SelectDefault(NewQModelIndexFromPointer(index), QItemSelectionModel__SelectionFlag(command))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectSelect(f func(index *QModelIndex, command QItemSelectionModel__SelectionFlag)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::select")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "select", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectSelect() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::select")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "select")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) Select(index QModelIndex_ITF, command QItemSelectionModel__SelectionFlag) {
|
|
defer qt.Recovering("QItemSelectionModel::select")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_Select(ptr.Pointer(), PointerFromQModelIndex(index), C.int(command))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) SelectDefault(index QModelIndex_ITF, command QItemSelectionModel__SelectionFlag) {
|
|
defer qt.Recovering("QItemSelectionModel::select")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_SelectDefault(ptr.Pointer(), PointerFromQModelIndex(index), C.int(command))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) Selection() *QItemSelection {
|
|
defer qt.Recovering("QItemSelectionModel::selection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QItemSelectionModel_Selection(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_SelectionChanged
|
|
func callbackQItemSelectionModel_SelectionChanged(ptr unsafe.Pointer, ptrName *C.char, selected unsafe.Pointer, deselected unsafe.Pointer) {
|
|
defer qt.Recovering("callback QItemSelectionModel::selectionChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "selectionChanged"); signal != nil {
|
|
signal.(func(*QItemSelection, *QItemSelection))(NewQItemSelectionFromPointer(selected), NewQItemSelectionFromPointer(deselected))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectSelectionChanged(f func(selected *QItemSelection, deselected *QItemSelection)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::selectionChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ConnectSelectionChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "selectionChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectSelectionChanged() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::selectionChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_DisconnectSelectionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "selectionChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) SelectionChanged(selected QItemSelection_ITF, deselected QItemSelection_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::selectionChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_SelectionChanged(ptr.Pointer(), PointerFromQItemSelection(selected), PointerFromQItemSelection(deselected))
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_SetCurrentIndex
|
|
func callbackQItemSelectionModel_SetCurrentIndex(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, command C.int) {
|
|
defer qt.Recovering("callback QItemSelectionModel::setCurrentIndex")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setCurrentIndex"); signal != nil {
|
|
signal.(func(*QModelIndex, QItemSelectionModel__SelectionFlag))(NewQModelIndexFromPointer(index), QItemSelectionModel__SelectionFlag(command))
|
|
} else {
|
|
NewQItemSelectionModelFromPointer(ptr).SetCurrentIndexDefault(NewQModelIndexFromPointer(index), QItemSelectionModel__SelectionFlag(command))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectSetCurrentIndex(f func(index *QModelIndex, command QItemSelectionModel__SelectionFlag)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::setCurrentIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setCurrentIndex", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectSetCurrentIndex() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::setCurrentIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setCurrentIndex")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) SetCurrentIndex(index QModelIndex_ITF, command QItemSelectionModel__SelectionFlag) {
|
|
defer qt.Recovering("QItemSelectionModel::setCurrentIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_SetCurrentIndex(ptr.Pointer(), PointerFromQModelIndex(index), C.int(command))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) SetCurrentIndexDefault(index QModelIndex_ITF, command QItemSelectionModel__SelectionFlag) {
|
|
defer qt.Recovering("QItemSelectionModel::setCurrentIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_SetCurrentIndexDefault(ptr.Pointer(), PointerFromQModelIndex(index), C.int(command))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) SetModel(model QAbstractItemModel_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::setModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_SetModel(ptr.Pointer(), PointerFromQAbstractItemModel(model))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DestroyQItemSelectionModel() {
|
|
defer qt.Recovering("QItemSelectionModel::~QItemSelectionModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QItemSelectionModel_DestroyQItemSelectionModel(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_TimerEvent
|
|
func callbackQItemSelectionModel_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QItemSelectionModel::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQItemSelectionModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_ChildEvent
|
|
func callbackQItemSelectionModel_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QItemSelectionModel::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQItemSelectionModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_ConnectNotify
|
|
func callbackQItemSelectionModel_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QItemSelectionModel::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQItemSelectionModelFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_CustomEvent
|
|
func callbackQItemSelectionModel_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QItemSelectionModel::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQItemSelectionModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_DeleteLater
|
|
func callbackQItemSelectionModel_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QItemSelectionModel::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQItemSelectionModelFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QItemSelectionModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DeleteLater() {
|
|
defer qt.Recovering("QItemSelectionModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QItemSelectionModel_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DeleteLaterDefault() {
|
|
defer qt.Recovering("QItemSelectionModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QItemSelectionModel_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_DisconnectNotify
|
|
func callbackQItemSelectionModel_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QItemSelectionModel::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQItemSelectionModelFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QItemSelectionModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QItemSelectionModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionModel_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_Event
|
|
func callbackQItemSelectionModel_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QItemSelectionModel::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQItemSelectionModelFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QItemSelectionModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QItemSelectionModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionModel_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QItemSelectionModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionModel_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_EventFilter
|
|
func callbackQItemSelectionModel_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QItemSelectionModel::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQItemSelectionModelFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QItemSelectionModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QItemSelectionModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionModel_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QItemSelectionModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionModel_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQItemSelectionModel_MetaObject
|
|
func callbackQItemSelectionModel_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QItemSelectionModel::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQItemSelectionModelFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QItemSelectionModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QItemSelectionModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QItemSelectionModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QItemSelectionModel_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QItemSelectionModel) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QItemSelectionModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QItemSelectionModel_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QItemSelectionRange struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QItemSelectionRange_ITF interface {
|
|
QItemSelectionRange_PTR() *QItemSelectionRange
|
|
}
|
|
|
|
func (p *QItemSelectionRange) QItemSelectionRange_PTR() *QItemSelectionRange {
|
|
return p
|
|
}
|
|
|
|
func (p *QItemSelectionRange) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QItemSelectionRange) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQItemSelectionRange(ptr QItemSelectionRange_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QItemSelectionRange_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQItemSelectionRangeFromPointer(ptr unsafe.Pointer) *QItemSelectionRange {
|
|
var n = new(QItemSelectionRange)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQItemSelectionRangeFromPointer(ptr unsafe.Pointer) *QItemSelectionRange {
|
|
var n = NewQItemSelectionRangeFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Intersected(other QItemSelectionRange_ITF) *QItemSelectionRange {
|
|
defer qt.Recovering("QItemSelectionRange::intersected")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionRangeFromPointer(C.QItemSelectionRange_Intersected(ptr.Pointer(), PointerFromQItemSelectionRange(other)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Intersects(other QItemSelectionRange_ITF) bool {
|
|
defer qt.Recovering("QItemSelectionRange::intersects")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionRange_Intersects(ptr.Pointer(), PointerFromQItemSelectionRange(other)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func NewQItemSelectionRange() *QItemSelectionRange {
|
|
defer qt.Recovering("QItemSelectionRange::QItemSelectionRange")
|
|
|
|
return newQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange())
|
|
}
|
|
|
|
func NewQItemSelectionRange3(other QItemSelectionRange_ITF) *QItemSelectionRange {
|
|
defer qt.Recovering("QItemSelectionRange::QItemSelectionRange")
|
|
|
|
return newQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange3(PointerFromQItemSelectionRange(other)))
|
|
}
|
|
|
|
func NewQItemSelectionRange2(other QItemSelectionRange_ITF) *QItemSelectionRange {
|
|
defer qt.Recovering("QItemSelectionRange::QItemSelectionRange")
|
|
|
|
return newQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange2(PointerFromQItemSelectionRange(other)))
|
|
}
|
|
|
|
func NewQItemSelectionRange5(index QModelIndex_ITF) *QItemSelectionRange {
|
|
defer qt.Recovering("QItemSelectionRange::QItemSelectionRange")
|
|
|
|
return newQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange5(PointerFromQModelIndex(index)))
|
|
}
|
|
|
|
func NewQItemSelectionRange4(topLeft QModelIndex_ITF, bottomRight QModelIndex_ITF) *QItemSelectionRange {
|
|
defer qt.Recovering("QItemSelectionRange::QItemSelectionRange")
|
|
|
|
return newQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange4(PointerFromQModelIndex(topLeft), PointerFromQModelIndex(bottomRight)))
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Bottom() int {
|
|
defer qt.Recovering("QItemSelectionRange::bottom")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QItemSelectionRange_Bottom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) BottomRight() *QPersistentModelIndex {
|
|
defer qt.Recovering("QItemSelectionRange::bottomRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPersistentModelIndexFromPointer(C.QItemSelectionRange_BottomRight(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Contains(index QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QItemSelectionRange::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionRange_Contains(ptr.Pointer(), PointerFromQModelIndex(index)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Contains2(row int, column int, parentIndex QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QItemSelectionRange::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionRange_Contains2(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parentIndex)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Height() int {
|
|
defer qt.Recovering("QItemSelectionRange::height")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QItemSelectionRange_Height(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) IsEmpty() bool {
|
|
defer qt.Recovering("QItemSelectionRange::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionRange_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) IsValid() bool {
|
|
defer qt.Recovering("QItemSelectionRange::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QItemSelectionRange_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Left() int {
|
|
defer qt.Recovering("QItemSelectionRange::left")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QItemSelectionRange_Left(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Model() *QAbstractItemModel {
|
|
defer qt.Recovering("QItemSelectionRange::model")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractItemModelFromPointer(C.QItemSelectionRange_Model(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Parent() *QModelIndex {
|
|
defer qt.Recovering("QItemSelectionRange::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QItemSelectionRange_Parent(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Right() int {
|
|
defer qt.Recovering("QItemSelectionRange::right")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QItemSelectionRange_Right(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Swap(other QItemSelectionRange_ITF) {
|
|
defer qt.Recovering("QItemSelectionRange::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QItemSelectionRange_Swap(ptr.Pointer(), PointerFromQItemSelectionRange(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Top() int {
|
|
defer qt.Recovering("QItemSelectionRange::top")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QItemSelectionRange_Top(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) TopLeft() *QPersistentModelIndex {
|
|
defer qt.Recovering("QItemSelectionRange::topLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPersistentModelIndexFromPointer(C.QItemSelectionRange_TopLeft(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QItemSelectionRange) Width() int {
|
|
defer qt.Recovering("QItemSelectionRange::width")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QItemSelectionRange_Width(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QJsonArray struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QJsonArray_ITF interface {
|
|
QJsonArray_PTR() *QJsonArray
|
|
}
|
|
|
|
func (p *QJsonArray) QJsonArray_PTR() *QJsonArray {
|
|
return p
|
|
}
|
|
|
|
func (p *QJsonArray) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QJsonArray) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQJsonArray(ptr QJsonArray_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QJsonArray_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQJsonArrayFromPointer(ptr unsafe.Pointer) *QJsonArray {
|
|
var n = new(QJsonArray)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQJsonArrayFromPointer(ptr unsafe.Pointer) *QJsonArray {
|
|
var n = NewQJsonArrayFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQJsonArray() *QJsonArray {
|
|
defer qt.Recovering("QJsonArray::QJsonArray")
|
|
|
|
return newQJsonArrayFromPointer(C.QJsonArray_NewQJsonArray())
|
|
}
|
|
|
|
func NewQJsonArray3(other QJsonArray_ITF) *QJsonArray {
|
|
defer qt.Recovering("QJsonArray::QJsonArray")
|
|
|
|
return newQJsonArrayFromPointer(C.QJsonArray_NewQJsonArray3(PointerFromQJsonArray(other)))
|
|
}
|
|
|
|
func (ptr *QJsonArray) Append(value QJsonValue_ITF) {
|
|
defer qt.Recovering("QJsonArray::append")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonArray_Append(ptr.Pointer(), PointerFromQJsonValue(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonArray) At(i int) *QJsonValue {
|
|
defer qt.Recovering("QJsonArray::at")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonValueFromPointer(C.QJsonArray_At(ptr.Pointer(), C.int(i)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QJsonArray) Contains(value QJsonValue_ITF) bool {
|
|
defer qt.Recovering("QJsonArray::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonArray_Contains(ptr.Pointer(), PointerFromQJsonValue(value)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonArray) Count() int {
|
|
defer qt.Recovering("QJsonArray::count")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QJsonArray_Count(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QJsonArray) Empty() bool {
|
|
defer qt.Recovering("QJsonArray::empty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonArray_Empty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonArray) First() *QJsonValue {
|
|
defer qt.Recovering("QJsonArray::first")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonValueFromPointer(C.QJsonArray_First(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func QJsonArray_FromStringList(list []string) *QJsonArray {
|
|
defer qt.Recovering("QJsonArray::fromStringList")
|
|
|
|
return NewQJsonArrayFromPointer(C.QJsonArray_QJsonArray_FromStringList(C.CString(strings.Join(list, "|"))))
|
|
}
|
|
|
|
func (ptr *QJsonArray) FromStringList(list []string) *QJsonArray {
|
|
defer qt.Recovering("QJsonArray::fromStringList")
|
|
|
|
return NewQJsonArrayFromPointer(C.QJsonArray_QJsonArray_FromStringList(C.CString(strings.Join(list, "|"))))
|
|
}
|
|
|
|
func (ptr *QJsonArray) Insert(i int, value QJsonValue_ITF) {
|
|
defer qt.Recovering("QJsonArray::insert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonArray_Insert(ptr.Pointer(), C.int(i), PointerFromQJsonValue(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonArray) IsEmpty() bool {
|
|
defer qt.Recovering("QJsonArray::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonArray_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonArray) Last() *QJsonValue {
|
|
defer qt.Recovering("QJsonArray::last")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonValueFromPointer(C.QJsonArray_Last(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QJsonArray) Pop_back() {
|
|
defer qt.Recovering("QJsonArray::pop_back")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonArray_Pop_back(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonArray) Pop_front() {
|
|
defer qt.Recovering("QJsonArray::pop_front")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonArray_Pop_front(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonArray) Prepend(value QJsonValue_ITF) {
|
|
defer qt.Recovering("QJsonArray::prepend")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonArray_Prepend(ptr.Pointer(), PointerFromQJsonValue(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonArray) Push_back(value QJsonValue_ITF) {
|
|
defer qt.Recovering("QJsonArray::push_back")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonArray_Push_back(ptr.Pointer(), PointerFromQJsonValue(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonArray) Push_front(value QJsonValue_ITF) {
|
|
defer qt.Recovering("QJsonArray::push_front")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonArray_Push_front(ptr.Pointer(), PointerFromQJsonValue(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonArray) RemoveAt(i int) {
|
|
defer qt.Recovering("QJsonArray::removeAt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonArray_RemoveAt(ptr.Pointer(), C.int(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonArray) RemoveFirst() {
|
|
defer qt.Recovering("QJsonArray::removeFirst")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonArray_RemoveFirst(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonArray) RemoveLast() {
|
|
defer qt.Recovering("QJsonArray::removeLast")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonArray_RemoveLast(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonArray) Replace(i int, value QJsonValue_ITF) {
|
|
defer qt.Recovering("QJsonArray::replace")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonArray_Replace(ptr.Pointer(), C.int(i), PointerFromQJsonValue(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonArray) Size() int {
|
|
defer qt.Recovering("QJsonArray::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QJsonArray_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QJsonArray) TakeAt(i int) *QJsonValue {
|
|
defer qt.Recovering("QJsonArray::takeAt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonValueFromPointer(C.QJsonArray_TakeAt(ptr.Pointer(), C.int(i)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QJsonArray) DestroyQJsonArray() {
|
|
defer qt.Recovering("QJsonArray::~QJsonArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonArray_DestroyQJsonArray(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QJsonDocument::DataValidation
|
|
type QJsonDocument__DataValidation int64
|
|
|
|
const (
|
|
QJsonDocument__Validate = QJsonDocument__DataValidation(0)
|
|
QJsonDocument__BypassValidation = QJsonDocument__DataValidation(1)
|
|
)
|
|
|
|
//QJsonDocument::JsonFormat
|
|
type QJsonDocument__JsonFormat int64
|
|
|
|
const (
|
|
QJsonDocument__Indented = QJsonDocument__JsonFormat(0)
|
|
QJsonDocument__Compact = QJsonDocument__JsonFormat(1)
|
|
)
|
|
|
|
type QJsonDocument struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QJsonDocument_ITF interface {
|
|
QJsonDocument_PTR() *QJsonDocument
|
|
}
|
|
|
|
func (p *QJsonDocument) QJsonDocument_PTR() *QJsonDocument {
|
|
return p
|
|
}
|
|
|
|
func (p *QJsonDocument) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QJsonDocument) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQJsonDocument(ptr QJsonDocument_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QJsonDocument_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQJsonDocumentFromPointer(ptr unsafe.Pointer) *QJsonDocument {
|
|
var n = new(QJsonDocument)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQJsonDocumentFromPointer(ptr unsafe.Pointer) *QJsonDocument {
|
|
var n = NewQJsonDocumentFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQJsonDocument() *QJsonDocument {
|
|
defer qt.Recovering("QJsonDocument::QJsonDocument")
|
|
|
|
return newQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument())
|
|
}
|
|
|
|
func NewQJsonDocument3(array QJsonArray_ITF) *QJsonDocument {
|
|
defer qt.Recovering("QJsonDocument::QJsonDocument")
|
|
|
|
return newQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument3(PointerFromQJsonArray(array)))
|
|
}
|
|
|
|
func NewQJsonDocument4(other QJsonDocument_ITF) *QJsonDocument {
|
|
defer qt.Recovering("QJsonDocument::QJsonDocument")
|
|
|
|
return newQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument4(PointerFromQJsonDocument(other)))
|
|
}
|
|
|
|
func NewQJsonDocument2(object QJsonObject_ITF) *QJsonDocument {
|
|
defer qt.Recovering("QJsonDocument::QJsonDocument")
|
|
|
|
return newQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument2(PointerFromQJsonObject(object)))
|
|
}
|
|
|
|
func (ptr *QJsonDocument) Array() *QJsonArray {
|
|
defer qt.Recovering("QJsonDocument::array")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonArrayFromPointer(C.QJsonDocument_Array(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func QJsonDocument_FromBinaryData(data string, validation QJsonDocument__DataValidation) *QJsonDocument {
|
|
defer qt.Recovering("QJsonDocument::fromBinaryData")
|
|
|
|
return NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromBinaryData(C.CString(data), C.int(validation)))
|
|
}
|
|
|
|
func (ptr *QJsonDocument) FromBinaryData(data string, validation QJsonDocument__DataValidation) *QJsonDocument {
|
|
defer qt.Recovering("QJsonDocument::fromBinaryData")
|
|
|
|
return NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromBinaryData(C.CString(data), C.int(validation)))
|
|
}
|
|
|
|
func QJsonDocument_FromJson(json string, error QJsonParseError_ITF) *QJsonDocument {
|
|
defer qt.Recovering("QJsonDocument::fromJson")
|
|
|
|
return NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromJson(C.CString(json), PointerFromQJsonParseError(error)))
|
|
}
|
|
|
|
func (ptr *QJsonDocument) FromJson(json string, error QJsonParseError_ITF) *QJsonDocument {
|
|
defer qt.Recovering("QJsonDocument::fromJson")
|
|
|
|
return NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromJson(C.CString(json), PointerFromQJsonParseError(error)))
|
|
}
|
|
|
|
func QJsonDocument_FromRawData(data string, size int, validation QJsonDocument__DataValidation) *QJsonDocument {
|
|
defer qt.Recovering("QJsonDocument::fromRawData")
|
|
|
|
return NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromRawData(C.CString(data), C.int(size), C.int(validation)))
|
|
}
|
|
|
|
func (ptr *QJsonDocument) FromRawData(data string, size int, validation QJsonDocument__DataValidation) *QJsonDocument {
|
|
defer qt.Recovering("QJsonDocument::fromRawData")
|
|
|
|
return NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromRawData(C.CString(data), C.int(size), C.int(validation)))
|
|
}
|
|
|
|
func QJsonDocument_FromVariant(variant QVariant_ITF) *QJsonDocument {
|
|
defer qt.Recovering("QJsonDocument::fromVariant")
|
|
|
|
return NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromVariant(PointerFromQVariant(variant)))
|
|
}
|
|
|
|
func (ptr *QJsonDocument) FromVariant(variant QVariant_ITF) *QJsonDocument {
|
|
defer qt.Recovering("QJsonDocument::fromVariant")
|
|
|
|
return NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromVariant(PointerFromQVariant(variant)))
|
|
}
|
|
|
|
func (ptr *QJsonDocument) IsArray() bool {
|
|
defer qt.Recovering("QJsonDocument::isArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonDocument_IsArray(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonDocument) IsEmpty() bool {
|
|
defer qt.Recovering("QJsonDocument::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonDocument_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonDocument) IsNull() bool {
|
|
defer qt.Recovering("QJsonDocument::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonDocument_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonDocument) IsObject() bool {
|
|
defer qt.Recovering("QJsonDocument::isObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonDocument_IsObject(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonDocument) Object() *QJsonObject {
|
|
defer qt.Recovering("QJsonDocument::object")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonObjectFromPointer(C.QJsonDocument_Object(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QJsonDocument) RawData(size int) string {
|
|
defer qt.Recovering("QJsonDocument::rawData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QJsonDocument_RawData(ptr.Pointer(), C.int(size)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QJsonDocument) SetArray(array QJsonArray_ITF) {
|
|
defer qt.Recovering("QJsonDocument::setArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonDocument_SetArray(ptr.Pointer(), PointerFromQJsonArray(array))
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonDocument) SetObject(object QJsonObject_ITF) {
|
|
defer qt.Recovering("QJsonDocument::setObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonDocument_SetObject(ptr.Pointer(), PointerFromQJsonObject(object))
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonDocument) ToBinaryData() string {
|
|
defer qt.Recovering("QJsonDocument::toBinaryData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QJsonDocument_ToBinaryData(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QJsonDocument) ToJson(format QJsonDocument__JsonFormat) string {
|
|
defer qt.Recovering("QJsonDocument::toJson")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QJsonDocument_ToJson(ptr.Pointer(), C.int(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QJsonDocument) ToVariant() *QVariant {
|
|
defer qt.Recovering("QJsonDocument::toVariant")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QJsonDocument_ToVariant(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QJsonDocument) DestroyQJsonDocument() {
|
|
defer qt.Recovering("QJsonDocument::~QJsonDocument")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonDocument_DestroyQJsonDocument(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QJsonObject struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QJsonObject_ITF interface {
|
|
QJsonObject_PTR() *QJsonObject
|
|
}
|
|
|
|
func (p *QJsonObject) QJsonObject_PTR() *QJsonObject {
|
|
return p
|
|
}
|
|
|
|
func (p *QJsonObject) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QJsonObject) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQJsonObject(ptr QJsonObject_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QJsonObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQJsonObjectFromPointer(ptr unsafe.Pointer) *QJsonObject {
|
|
var n = new(QJsonObject)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQJsonObjectFromPointer(ptr unsafe.Pointer) *QJsonObject {
|
|
var n = NewQJsonObjectFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQJsonObject() *QJsonObject {
|
|
defer qt.Recovering("QJsonObject::QJsonObject")
|
|
|
|
return newQJsonObjectFromPointer(C.QJsonObject_NewQJsonObject())
|
|
}
|
|
|
|
func NewQJsonObject3(other QJsonObject_ITF) *QJsonObject {
|
|
defer qt.Recovering("QJsonObject::QJsonObject")
|
|
|
|
return newQJsonObjectFromPointer(C.QJsonObject_NewQJsonObject3(PointerFromQJsonObject(other)))
|
|
}
|
|
|
|
func (ptr *QJsonObject) Contains(key string) bool {
|
|
defer qt.Recovering("QJsonObject::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonObject_Contains(ptr.Pointer(), C.CString(key)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonObject) Count() int {
|
|
defer qt.Recovering("QJsonObject::count")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QJsonObject_Count(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QJsonObject) Empty() bool {
|
|
defer qt.Recovering("QJsonObject::empty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonObject_Empty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonObject) IsEmpty() bool {
|
|
defer qt.Recovering("QJsonObject::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonObject_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonObject) Keys() []string {
|
|
defer qt.Recovering("QJsonObject::keys")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QJsonObject_Keys(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QJsonObject) Length() int {
|
|
defer qt.Recovering("QJsonObject::length")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QJsonObject_Length(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QJsonObject) Remove(key string) {
|
|
defer qt.Recovering("QJsonObject::remove")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonObject_Remove(ptr.Pointer(), C.CString(key))
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonObject) Size() int {
|
|
defer qt.Recovering("QJsonObject::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QJsonObject_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QJsonObject) Take(key string) *QJsonValue {
|
|
defer qt.Recovering("QJsonObject::take")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonValueFromPointer(C.QJsonObject_Take(ptr.Pointer(), C.CString(key)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QJsonObject) Value(key string) *QJsonValue {
|
|
defer qt.Recovering("QJsonObject::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonValueFromPointer(C.QJsonObject_Value(ptr.Pointer(), C.CString(key)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QJsonObject) DestroyQJsonObject() {
|
|
defer qt.Recovering("QJsonObject::~QJsonObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonObject_DestroyQJsonObject(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QJsonParseError::ParseError
|
|
type QJsonParseError__ParseError int64
|
|
|
|
const (
|
|
QJsonParseError__NoError = QJsonParseError__ParseError(0)
|
|
QJsonParseError__UnterminatedObject = QJsonParseError__ParseError(1)
|
|
QJsonParseError__MissingNameSeparator = QJsonParseError__ParseError(2)
|
|
QJsonParseError__UnterminatedArray = QJsonParseError__ParseError(3)
|
|
QJsonParseError__MissingValueSeparator = QJsonParseError__ParseError(4)
|
|
QJsonParseError__IllegalValue = QJsonParseError__ParseError(5)
|
|
QJsonParseError__TerminationByNumber = QJsonParseError__ParseError(6)
|
|
QJsonParseError__IllegalNumber = QJsonParseError__ParseError(7)
|
|
QJsonParseError__IllegalEscapeSequence = QJsonParseError__ParseError(8)
|
|
QJsonParseError__IllegalUTF8String = QJsonParseError__ParseError(9)
|
|
QJsonParseError__UnterminatedString = QJsonParseError__ParseError(10)
|
|
QJsonParseError__MissingObject = QJsonParseError__ParseError(11)
|
|
QJsonParseError__DeepNesting = QJsonParseError__ParseError(12)
|
|
QJsonParseError__DocumentTooLarge = QJsonParseError__ParseError(13)
|
|
QJsonParseError__GarbageAtEnd = QJsonParseError__ParseError(14)
|
|
)
|
|
|
|
type QJsonParseError struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QJsonParseError_ITF interface {
|
|
QJsonParseError_PTR() *QJsonParseError
|
|
}
|
|
|
|
func (p *QJsonParseError) QJsonParseError_PTR() *QJsonParseError {
|
|
return p
|
|
}
|
|
|
|
func (p *QJsonParseError) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QJsonParseError) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQJsonParseError(ptr QJsonParseError_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QJsonParseError_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQJsonParseErrorFromPointer(ptr unsafe.Pointer) *QJsonParseError {
|
|
var n = new(QJsonParseError)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQJsonParseErrorFromPointer(ptr unsafe.Pointer) *QJsonParseError {
|
|
var n = NewQJsonParseErrorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QJsonParseError) ErrorString() string {
|
|
defer qt.Recovering("QJsonParseError::errorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QJsonParseError_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QJsonParseError) Error() QJsonParseError__ParseError {
|
|
defer qt.Recovering("QJsonParseError::error")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QJsonParseError__ParseError(C.QJsonParseError_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QJsonParseError) SetError(vpa QJsonParseError__ParseError) {
|
|
defer qt.Recovering("QJsonParseError::setError")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonParseError_SetError(ptr.Pointer(), C.int(vpa))
|
|
}
|
|
}
|
|
|
|
func (ptr *QJsonParseError) Offset() int {
|
|
defer qt.Recovering("QJsonParseError::offset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QJsonParseError_Offset(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QJsonParseError) SetOffset(vin int) {
|
|
defer qt.Recovering("QJsonParseError::setOffset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonParseError_SetOffset(ptr.Pointer(), C.int(vin))
|
|
}
|
|
}
|
|
|
|
//QJsonValue::Type
|
|
type QJsonValue__Type int64
|
|
|
|
const (
|
|
QJsonValue__Null = QJsonValue__Type(0x0)
|
|
QJsonValue__Bool = QJsonValue__Type(0x1)
|
|
QJsonValue__Double = QJsonValue__Type(0x2)
|
|
QJsonValue__String = QJsonValue__Type(0x3)
|
|
QJsonValue__Array = QJsonValue__Type(0x4)
|
|
QJsonValue__Object = QJsonValue__Type(0x5)
|
|
QJsonValue__Undefined = QJsonValue__Type(0x80)
|
|
)
|
|
|
|
type QJsonValue struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QJsonValue_ITF interface {
|
|
QJsonValue_PTR() *QJsonValue
|
|
}
|
|
|
|
func (p *QJsonValue) QJsonValue_PTR() *QJsonValue {
|
|
return p
|
|
}
|
|
|
|
func (p *QJsonValue) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QJsonValue) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQJsonValue(ptr QJsonValue_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QJsonValue_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQJsonValueFromPointer(ptr unsafe.Pointer) *QJsonValue {
|
|
var n = new(QJsonValue)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQJsonValueFromPointer(ptr unsafe.Pointer) *QJsonValue {
|
|
var n = NewQJsonValueFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQJsonValue7(s QLatin1String_ITF) *QJsonValue {
|
|
defer qt.Recovering("QJsonValue::QJsonValue")
|
|
|
|
return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue7(PointerFromQLatin1String(s)))
|
|
}
|
|
|
|
func NewQJsonValue(ty QJsonValue__Type) *QJsonValue {
|
|
defer qt.Recovering("QJsonValue::QJsonValue")
|
|
|
|
return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue(C.int(ty)))
|
|
}
|
|
|
|
func NewQJsonValue2(b bool) *QJsonValue {
|
|
defer qt.Recovering("QJsonValue::QJsonValue")
|
|
|
|
return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue2(C.int(qt.GoBoolToInt(b))))
|
|
}
|
|
|
|
func NewQJsonValue9(a QJsonArray_ITF) *QJsonValue {
|
|
defer qt.Recovering("QJsonValue::QJsonValue")
|
|
|
|
return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue9(PointerFromQJsonArray(a)))
|
|
}
|
|
|
|
func NewQJsonValue10(o QJsonObject_ITF) *QJsonValue {
|
|
defer qt.Recovering("QJsonValue::QJsonValue")
|
|
|
|
return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue10(PointerFromQJsonObject(o)))
|
|
}
|
|
|
|
func NewQJsonValue11(other QJsonValue_ITF) *QJsonValue {
|
|
defer qt.Recovering("QJsonValue::QJsonValue")
|
|
|
|
return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue11(PointerFromQJsonValue(other)))
|
|
}
|
|
|
|
func NewQJsonValue6(s string) *QJsonValue {
|
|
defer qt.Recovering("QJsonValue::QJsonValue")
|
|
|
|
return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue6(C.CString(s)))
|
|
}
|
|
|
|
func NewQJsonValue8(s string) *QJsonValue {
|
|
defer qt.Recovering("QJsonValue::QJsonValue")
|
|
|
|
return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue8(C.CString(s)))
|
|
}
|
|
|
|
func NewQJsonValue4(n int) *QJsonValue {
|
|
defer qt.Recovering("QJsonValue::QJsonValue")
|
|
|
|
return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue4(C.int(n)))
|
|
}
|
|
|
|
func NewQJsonValue5(n int64) *QJsonValue {
|
|
defer qt.Recovering("QJsonValue::QJsonValue")
|
|
|
|
return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue5(C.longlong(n)))
|
|
}
|
|
|
|
func QJsonValue_FromVariant(variant QVariant_ITF) *QJsonValue {
|
|
defer qt.Recovering("QJsonValue::fromVariant")
|
|
|
|
return NewQJsonValueFromPointer(C.QJsonValue_QJsonValue_FromVariant(PointerFromQVariant(variant)))
|
|
}
|
|
|
|
func (ptr *QJsonValue) FromVariant(variant QVariant_ITF) *QJsonValue {
|
|
defer qt.Recovering("QJsonValue::fromVariant")
|
|
|
|
return NewQJsonValueFromPointer(C.QJsonValue_QJsonValue_FromVariant(PointerFromQVariant(variant)))
|
|
}
|
|
|
|
func (ptr *QJsonValue) IsArray() bool {
|
|
defer qt.Recovering("QJsonValue::isArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonValue_IsArray(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonValue) IsBool() bool {
|
|
defer qt.Recovering("QJsonValue::isBool")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonValue_IsBool(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonValue) IsDouble() bool {
|
|
defer qt.Recovering("QJsonValue::isDouble")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonValue_IsDouble(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonValue) IsNull() bool {
|
|
defer qt.Recovering("QJsonValue::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonValue_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonValue) IsObject() bool {
|
|
defer qt.Recovering("QJsonValue::isObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonValue_IsObject(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonValue) IsString() bool {
|
|
defer qt.Recovering("QJsonValue::isString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonValue_IsString(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonValue) IsUndefined() bool {
|
|
defer qt.Recovering("QJsonValue::isUndefined")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonValue_IsUndefined(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonValue) ToArray2() *QJsonArray {
|
|
defer qt.Recovering("QJsonValue::toArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonArrayFromPointer(C.QJsonValue_ToArray2(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QJsonValue) ToArray(defaultValue QJsonArray_ITF) *QJsonArray {
|
|
defer qt.Recovering("QJsonValue::toArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonArrayFromPointer(C.QJsonValue_ToArray(ptr.Pointer(), PointerFromQJsonArray(defaultValue)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QJsonValue) ToBool(defaultValue bool) bool {
|
|
defer qt.Recovering("QJsonValue::toBool")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QJsonValue_ToBool(ptr.Pointer(), C.int(qt.GoBoolToInt(defaultValue))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QJsonValue) ToInt(defaultValue int) int {
|
|
defer qt.Recovering("QJsonValue::toInt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QJsonValue_ToInt(ptr.Pointer(), C.int(defaultValue)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QJsonValue) ToObject2() *QJsonObject {
|
|
defer qt.Recovering("QJsonValue::toObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonObjectFromPointer(C.QJsonValue_ToObject2(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QJsonValue) ToObject(defaultValue QJsonObject_ITF) *QJsonObject {
|
|
defer qt.Recovering("QJsonValue::toObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonObjectFromPointer(C.QJsonValue_ToObject(ptr.Pointer(), PointerFromQJsonObject(defaultValue)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QJsonValue) ToString(defaultValue string) string {
|
|
defer qt.Recovering("QJsonValue::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QJsonValue_ToString(ptr.Pointer(), C.CString(defaultValue)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QJsonValue) ToVariant() *QVariant {
|
|
defer qt.Recovering("QJsonValue::toVariant")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QJsonValue_ToVariant(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QJsonValue) Type() QJsonValue__Type {
|
|
defer qt.Recovering("QJsonValue::type")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QJsonValue__Type(C.QJsonValue_Type(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QJsonValue) DestroyQJsonValue() {
|
|
defer qt.Recovering("QJsonValue::~QJsonValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QJsonValue_DestroyQJsonValue(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QLatin1Char struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QLatin1Char_ITF interface {
|
|
QLatin1Char_PTR() *QLatin1Char
|
|
}
|
|
|
|
func (p *QLatin1Char) QLatin1Char_PTR() *QLatin1Char {
|
|
return p
|
|
}
|
|
|
|
func (p *QLatin1Char) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QLatin1Char) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQLatin1Char(ptr QLatin1Char_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QLatin1Char_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQLatin1CharFromPointer(ptr unsafe.Pointer) *QLatin1Char {
|
|
var n = new(QLatin1Char)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQLatin1CharFromPointer(ptr unsafe.Pointer) *QLatin1Char {
|
|
var n = NewQLatin1CharFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQLatin1Char(c string) *QLatin1Char {
|
|
defer qt.Recovering("QLatin1Char::QLatin1Char")
|
|
|
|
return newQLatin1CharFromPointer(C.QLatin1Char_NewQLatin1Char(C.CString(c)))
|
|
}
|
|
|
|
func (ptr *QLatin1Char) ToLatin1() string {
|
|
defer qt.Recovering("QLatin1Char::toLatin1")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLatin1Char_ToLatin1(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type QLatin1String struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QLatin1String_ITF interface {
|
|
QLatin1String_PTR() *QLatin1String
|
|
}
|
|
|
|
func (p *QLatin1String) QLatin1String_PTR() *QLatin1String {
|
|
return p
|
|
}
|
|
|
|
func (p *QLatin1String) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QLatin1String) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQLatin1String(ptr QLatin1String_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QLatin1String_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQLatin1StringFromPointer(ptr unsafe.Pointer) *QLatin1String {
|
|
var n = new(QLatin1String)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQLatin1StringFromPointer(ptr unsafe.Pointer) *QLatin1String {
|
|
var n = NewQLatin1StringFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQLatin1String() *QLatin1String {
|
|
defer qt.Recovering("QLatin1String::QLatin1String")
|
|
|
|
return newQLatin1StringFromPointer(C.QLatin1String_NewQLatin1String())
|
|
}
|
|
|
|
func NewQLatin1String4(str string) *QLatin1String {
|
|
defer qt.Recovering("QLatin1String::QLatin1String")
|
|
|
|
return newQLatin1StringFromPointer(C.QLatin1String_NewQLatin1String4(C.CString(str)))
|
|
}
|
|
|
|
func NewQLatin1String2(str string) *QLatin1String {
|
|
defer qt.Recovering("QLatin1String::QLatin1String")
|
|
|
|
return newQLatin1StringFromPointer(C.QLatin1String_NewQLatin1String2(C.CString(str)))
|
|
}
|
|
|
|
func NewQLatin1String3(str string, size int) *QLatin1String {
|
|
defer qt.Recovering("QLatin1String::QLatin1String")
|
|
|
|
return newQLatin1StringFromPointer(C.QLatin1String_NewQLatin1String3(C.CString(str), C.int(size)))
|
|
}
|
|
|
|
func (ptr *QLatin1String) Data() string {
|
|
defer qt.Recovering("QLatin1String::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLatin1String_Data(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLatin1String) Latin1() string {
|
|
defer qt.Recovering("QLatin1String::latin1")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLatin1String_Latin1(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLatin1String) Size() int {
|
|
defer qt.Recovering("QLatin1String::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QLatin1String_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//QLibrary::LoadHint
|
|
type QLibrary__LoadHint int64
|
|
|
|
const (
|
|
QLibrary__ResolveAllSymbolsHint = QLibrary__LoadHint(0x01)
|
|
QLibrary__ExportExternalSymbolsHint = QLibrary__LoadHint(0x02)
|
|
QLibrary__LoadArchiveMemberHint = QLibrary__LoadHint(0x04)
|
|
QLibrary__PreventUnloadHint = QLibrary__LoadHint(0x08)
|
|
QLibrary__DeepBindHint = QLibrary__LoadHint(0x10)
|
|
)
|
|
|
|
type QLibrary struct {
|
|
QObject
|
|
}
|
|
|
|
type QLibrary_ITF interface {
|
|
QObject_ITF
|
|
QLibrary_PTR() *QLibrary
|
|
}
|
|
|
|
func (p *QLibrary) QLibrary_PTR() *QLibrary {
|
|
return p
|
|
}
|
|
|
|
func (p *QLibrary) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QLibrary) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQLibrary(ptr QLibrary_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QLibrary_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQLibraryFromPointer(ptr unsafe.Pointer) *QLibrary {
|
|
var n = new(QLibrary)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQLibraryFromPointer(ptr unsafe.Pointer) *QLibrary {
|
|
var n = NewQLibraryFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QLibrary_") {
|
|
n.SetObjectName("QLibrary_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QLibrary) FileName() string {
|
|
defer qt.Recovering("QLibrary::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLibrary_FileName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLibrary) LoadHints() QLibrary__LoadHint {
|
|
defer qt.Recovering("QLibrary::loadHints")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QLibrary__LoadHint(C.QLibrary_LoadHints(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLibrary) SetFileName(fileName string) {
|
|
defer qt.Recovering("QLibrary::setFileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_SetFileName(ptr.Pointer(), C.CString(fileName))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) SetFileNameAndVersion(fileName string, versionNumber int) {
|
|
defer qt.Recovering("QLibrary::setFileNameAndVersion")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_SetFileNameAndVersion(ptr.Pointer(), C.CString(fileName), C.int(versionNumber))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) SetLoadHints(hints QLibrary__LoadHint) {
|
|
defer qt.Recovering("QLibrary::setLoadHints")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_SetLoadHints(ptr.Pointer(), C.int(hints))
|
|
}
|
|
}
|
|
|
|
func NewQLibrary(parent QObject_ITF) *QLibrary {
|
|
defer qt.Recovering("QLibrary::QLibrary")
|
|
|
|
return newQLibraryFromPointer(C.QLibrary_NewQLibrary(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQLibrary2(fileName string, parent QObject_ITF) *QLibrary {
|
|
defer qt.Recovering("QLibrary::QLibrary")
|
|
|
|
return newQLibraryFromPointer(C.QLibrary_NewQLibrary2(C.CString(fileName), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQLibrary4(fileName string, version string, parent QObject_ITF) *QLibrary {
|
|
defer qt.Recovering("QLibrary::QLibrary")
|
|
|
|
return newQLibraryFromPointer(C.QLibrary_NewQLibrary4(C.CString(fileName), C.CString(version), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQLibrary3(fileName string, verNum int, parent QObject_ITF) *QLibrary {
|
|
defer qt.Recovering("QLibrary::QLibrary")
|
|
|
|
return newQLibraryFromPointer(C.QLibrary_NewQLibrary3(C.CString(fileName), C.int(verNum), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QLibrary) ErrorString() string {
|
|
defer qt.Recovering("QLibrary::errorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLibrary_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func QLibrary_IsLibrary(fileName string) bool {
|
|
defer qt.Recovering("QLibrary::isLibrary")
|
|
|
|
return C.QLibrary_QLibrary_IsLibrary(C.CString(fileName)) != 0
|
|
}
|
|
|
|
func (ptr *QLibrary) IsLibrary(fileName string) bool {
|
|
defer qt.Recovering("QLibrary::isLibrary")
|
|
|
|
return C.QLibrary_QLibrary_IsLibrary(C.CString(fileName)) != 0
|
|
}
|
|
|
|
func (ptr *QLibrary) IsLoaded() bool {
|
|
defer qt.Recovering("QLibrary::isLoaded")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLibrary_IsLoaded(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLibrary) Load() bool {
|
|
defer qt.Recovering("QLibrary::load")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLibrary_Load(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLibrary) SetFileNameAndVersion2(fileName string, version string) {
|
|
defer qt.Recovering("QLibrary::setFileNameAndVersion")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_SetFileNameAndVersion2(ptr.Pointer(), C.CString(fileName), C.CString(version))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) Unload() bool {
|
|
defer qt.Recovering("QLibrary::unload")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLibrary_Unload(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLibrary) DestroyQLibrary() {
|
|
defer qt.Recovering("QLibrary::~QLibrary")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_DestroyQLibrary(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQLibrary_TimerEvent
|
|
func callbackQLibrary_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QLibrary::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQLibraryFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QLibrary::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QLibrary::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QLibrary::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QLibrary::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQLibrary_ChildEvent
|
|
func callbackQLibrary_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QLibrary::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQLibraryFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QLibrary::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QLibrary::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QLibrary::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QLibrary::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQLibrary_ConnectNotify
|
|
func callbackQLibrary_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QLibrary::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQLibraryFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QLibrary::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QLibrary::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QLibrary::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QLibrary::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQLibrary_CustomEvent
|
|
func callbackQLibrary_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QLibrary::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQLibraryFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QLibrary::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QLibrary::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QLibrary::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QLibrary::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQLibrary_DeleteLater
|
|
func callbackQLibrary_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QLibrary::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQLibraryFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QLibrary::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QLibrary::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DeleteLater() {
|
|
defer qt.Recovering("QLibrary::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DeleteLaterDefault() {
|
|
defer qt.Recovering("QLibrary::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQLibrary_DisconnectNotify
|
|
func callbackQLibrary_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QLibrary::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQLibraryFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QLibrary::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QLibrary::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QLibrary::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QLibrary::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLibrary_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQLibrary_Event
|
|
func callbackQLibrary_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QLibrary::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQLibraryFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QLibrary) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QLibrary::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QLibrary::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QLibrary::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLibrary_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLibrary) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QLibrary::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLibrary_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQLibrary_EventFilter
|
|
func callbackQLibrary_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QLibrary::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQLibraryFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QLibrary) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QLibrary::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QLibrary::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QLibrary::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLibrary_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLibrary) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QLibrary::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLibrary_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQLibrary_MetaObject
|
|
func callbackQLibrary_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QLibrary::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQLibraryFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QLibrary) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QLibrary::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QLibrary::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QLibrary) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QLibrary::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QLibrary_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLibrary) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QLibrary::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QLibrary_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//QLibraryInfo::LibraryLocation
|
|
type QLibraryInfo__LibraryLocation int64
|
|
|
|
const (
|
|
QLibraryInfo__PrefixPath = QLibraryInfo__LibraryLocation(0)
|
|
QLibraryInfo__DocumentationPath = QLibraryInfo__LibraryLocation(1)
|
|
QLibraryInfo__HeadersPath = QLibraryInfo__LibraryLocation(2)
|
|
QLibraryInfo__LibrariesPath = QLibraryInfo__LibraryLocation(3)
|
|
QLibraryInfo__LibraryExecutablesPath = QLibraryInfo__LibraryLocation(4)
|
|
QLibraryInfo__BinariesPath = QLibraryInfo__LibraryLocation(5)
|
|
QLibraryInfo__PluginsPath = QLibraryInfo__LibraryLocation(6)
|
|
QLibraryInfo__ImportsPath = QLibraryInfo__LibraryLocation(7)
|
|
QLibraryInfo__Qml2ImportsPath = QLibraryInfo__LibraryLocation(8)
|
|
QLibraryInfo__ArchDataPath = QLibraryInfo__LibraryLocation(9)
|
|
QLibraryInfo__DataPath = QLibraryInfo__LibraryLocation(10)
|
|
QLibraryInfo__TranslationsPath = QLibraryInfo__LibraryLocation(11)
|
|
QLibraryInfo__ExamplesPath = QLibraryInfo__LibraryLocation(12)
|
|
QLibraryInfo__TestsPath = QLibraryInfo__LibraryLocation(13)
|
|
QLibraryInfo__SettingsPath = QLibraryInfo__LibraryLocation(100)
|
|
)
|
|
|
|
type QLibraryInfo struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QLibraryInfo_ITF interface {
|
|
QLibraryInfo_PTR() *QLibraryInfo
|
|
}
|
|
|
|
func (p *QLibraryInfo) QLibraryInfo_PTR() *QLibraryInfo {
|
|
return p
|
|
}
|
|
|
|
func (p *QLibraryInfo) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QLibraryInfo) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQLibraryInfo(ptr QLibraryInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QLibraryInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQLibraryInfoFromPointer(ptr unsafe.Pointer) *QLibraryInfo {
|
|
var n = new(QLibraryInfo)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQLibraryInfoFromPointer(ptr unsafe.Pointer) *QLibraryInfo {
|
|
var n = NewQLibraryInfoFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func QLibraryInfo_IsDebugBuild() bool {
|
|
defer qt.Recovering("QLibraryInfo::isDebugBuild")
|
|
|
|
return C.QLibraryInfo_QLibraryInfo_IsDebugBuild() != 0
|
|
}
|
|
|
|
func (ptr *QLibraryInfo) IsDebugBuild() bool {
|
|
defer qt.Recovering("QLibraryInfo::isDebugBuild")
|
|
|
|
return C.QLibraryInfo_QLibraryInfo_IsDebugBuild() != 0
|
|
}
|
|
|
|
func QLibraryInfo_LicensedProducts() string {
|
|
defer qt.Recovering("QLibraryInfo::licensedProducts")
|
|
|
|
return C.GoString(C.QLibraryInfo_QLibraryInfo_LicensedProducts())
|
|
}
|
|
|
|
func (ptr *QLibraryInfo) LicensedProducts() string {
|
|
defer qt.Recovering("QLibraryInfo::licensedProducts")
|
|
|
|
return C.GoString(C.QLibraryInfo_QLibraryInfo_LicensedProducts())
|
|
}
|
|
|
|
func QLibraryInfo_Licensee() string {
|
|
defer qt.Recovering("QLibraryInfo::licensee")
|
|
|
|
return C.GoString(C.QLibraryInfo_QLibraryInfo_Licensee())
|
|
}
|
|
|
|
func (ptr *QLibraryInfo) Licensee() string {
|
|
defer qt.Recovering("QLibraryInfo::licensee")
|
|
|
|
return C.GoString(C.QLibraryInfo_QLibraryInfo_Licensee())
|
|
}
|
|
|
|
func QLibraryInfo_Location(loc QLibraryInfo__LibraryLocation) string {
|
|
defer qt.Recovering("QLibraryInfo::location")
|
|
|
|
return C.GoString(C.QLibraryInfo_QLibraryInfo_Location(C.int(loc)))
|
|
}
|
|
|
|
func (ptr *QLibraryInfo) Location(loc QLibraryInfo__LibraryLocation) string {
|
|
defer qt.Recovering("QLibraryInfo::location")
|
|
|
|
return C.GoString(C.QLibraryInfo_QLibraryInfo_Location(C.int(loc)))
|
|
}
|
|
|
|
type QLine struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QLine_ITF interface {
|
|
QLine_PTR() *QLine
|
|
}
|
|
|
|
func (p *QLine) QLine_PTR() *QLine {
|
|
return p
|
|
}
|
|
|
|
func (p *QLine) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QLine) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQLine(ptr QLine_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QLine_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQLineFromPointer(ptr unsafe.Pointer) *QLine {
|
|
var n = new(QLine)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQLineFromPointer(ptr unsafe.Pointer) *QLine {
|
|
var n = NewQLineFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQLine() *QLine {
|
|
defer qt.Recovering("QLine::QLine")
|
|
|
|
return newQLineFromPointer(C.QLine_NewQLine())
|
|
}
|
|
|
|
func NewQLine2(p1 QPoint_ITF, p2 QPoint_ITF) *QLine {
|
|
defer qt.Recovering("QLine::QLine")
|
|
|
|
return newQLineFromPointer(C.QLine_NewQLine2(PointerFromQPoint(p1), PointerFromQPoint(p2)))
|
|
}
|
|
|
|
func NewQLine3(x1 int, y1 int, x2 int, y2 int) *QLine {
|
|
defer qt.Recovering("QLine::QLine")
|
|
|
|
return newQLineFromPointer(C.QLine_NewQLine3(C.int(x1), C.int(y1), C.int(x2), C.int(y2)))
|
|
}
|
|
|
|
func (ptr *QLine) Dx() int {
|
|
defer qt.Recovering("QLine::dx")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QLine_Dx(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLine) Dy() int {
|
|
defer qt.Recovering("QLine::dy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QLine_Dy(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLine) IsNull() bool {
|
|
defer qt.Recovering("QLine::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLine_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLine) P1() *QPoint {
|
|
defer qt.Recovering("QLine::p1")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFromPointer(C.QLine_P1(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLine) P2() *QPoint {
|
|
defer qt.Recovering("QLine::p2")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFromPointer(C.QLine_P2(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLine) SetLine(x1 int, y1 int, x2 int, y2 int) {
|
|
defer qt.Recovering("QLine::setLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLine_SetLine(ptr.Pointer(), C.int(x1), C.int(y1), C.int(x2), C.int(y2))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLine) SetP1(p1 QPoint_ITF) {
|
|
defer qt.Recovering("QLine::setP1")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLine_SetP1(ptr.Pointer(), PointerFromQPoint(p1))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLine) SetP2(p2 QPoint_ITF) {
|
|
defer qt.Recovering("QLine::setP2")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLine_SetP2(ptr.Pointer(), PointerFromQPoint(p2))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLine) SetPoints(p1 QPoint_ITF, p2 QPoint_ITF) {
|
|
defer qt.Recovering("QLine::setPoints")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLine_SetPoints(ptr.Pointer(), PointerFromQPoint(p1), PointerFromQPoint(p2))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLine) Translate(offset QPoint_ITF) {
|
|
defer qt.Recovering("QLine::translate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLine_Translate(ptr.Pointer(), PointerFromQPoint(offset))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLine) Translate2(dx int, dy int) {
|
|
defer qt.Recovering("QLine::translate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLine_Translate2(ptr.Pointer(), C.int(dx), C.int(dy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLine) Translated(offset QPoint_ITF) *QLine {
|
|
defer qt.Recovering("QLine::translated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLineFromPointer(C.QLine_Translated(ptr.Pointer(), PointerFromQPoint(offset)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLine) Translated2(dx int, dy int) *QLine {
|
|
defer qt.Recovering("QLine::translated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLineFromPointer(C.QLine_Translated2(ptr.Pointer(), C.int(dx), C.int(dy)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLine) X1() int {
|
|
defer qt.Recovering("QLine::x1")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QLine_X1(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLine) X2() int {
|
|
defer qt.Recovering("QLine::x2")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QLine_X2(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLine) Y1() int {
|
|
defer qt.Recovering("QLine::y1")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QLine_Y1(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLine) Y2() int {
|
|
defer qt.Recovering("QLine::y2")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QLine_Y2(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//QLineF::IntersectType
|
|
type QLineF__IntersectType int64
|
|
|
|
const (
|
|
QLineF__NoIntersection = QLineF__IntersectType(0)
|
|
QLineF__BoundedIntersection = QLineF__IntersectType(1)
|
|
QLineF__UnboundedIntersection = QLineF__IntersectType(2)
|
|
)
|
|
|
|
type QLineF struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QLineF_ITF interface {
|
|
QLineF_PTR() *QLineF
|
|
}
|
|
|
|
func (p *QLineF) QLineF_PTR() *QLineF {
|
|
return p
|
|
}
|
|
|
|
func (p *QLineF) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QLineF) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQLineF(ptr QLineF_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QLineF_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQLineFFromPointer(ptr unsafe.Pointer) *QLineF {
|
|
var n = new(QLineF)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQLineFFromPointer(ptr unsafe.Pointer) *QLineF {
|
|
var n = NewQLineFFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QLineF) AngleTo(line QLineF_ITF) float64 {
|
|
defer qt.Recovering("QLineF::angleTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QLineF_AngleTo(ptr.Pointer(), PointerFromQLineF(line)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLineF) Intersect(line QLineF_ITF, intersectionPoint QPointF_ITF) QLineF__IntersectType {
|
|
defer qt.Recovering("QLineF::intersect")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QLineF__IntersectType(C.QLineF_Intersect(ptr.Pointer(), PointerFromQLineF(line), PointerFromQPointF(intersectionPoint)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func NewQLineF() *QLineF {
|
|
defer qt.Recovering("QLineF::QLineF")
|
|
|
|
return newQLineFFromPointer(C.QLineF_NewQLineF())
|
|
}
|
|
|
|
func NewQLineF4(line QLine_ITF) *QLineF {
|
|
defer qt.Recovering("QLineF::QLineF")
|
|
|
|
return newQLineFFromPointer(C.QLineF_NewQLineF4(PointerFromQLine(line)))
|
|
}
|
|
|
|
func NewQLineF2(p1 QPointF_ITF, p2 QPointF_ITF) *QLineF {
|
|
defer qt.Recovering("QLineF::QLineF")
|
|
|
|
return newQLineFFromPointer(C.QLineF_NewQLineF2(PointerFromQPointF(p1), PointerFromQPointF(p2)))
|
|
}
|
|
|
|
func NewQLineF3(x1 float64, y1 float64, x2 float64, y2 float64) *QLineF {
|
|
defer qt.Recovering("QLineF::QLineF")
|
|
|
|
return newQLineFFromPointer(C.QLineF_NewQLineF3(C.double(x1), C.double(y1), C.double(x2), C.double(y2)))
|
|
}
|
|
|
|
func (ptr *QLineF) Angle() float64 {
|
|
defer qt.Recovering("QLineF::angle")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QLineF_Angle(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLineF) Dx() float64 {
|
|
defer qt.Recovering("QLineF::dx")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QLineF_Dx(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLineF) Dy() float64 {
|
|
defer qt.Recovering("QLineF::dy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QLineF_Dy(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QLineF_FromPolar(length float64, angle float64) *QLineF {
|
|
defer qt.Recovering("QLineF::fromPolar")
|
|
|
|
return NewQLineFFromPointer(C.QLineF_QLineF_FromPolar(C.double(length), C.double(angle)))
|
|
}
|
|
|
|
func (ptr *QLineF) FromPolar(length float64, angle float64) *QLineF {
|
|
defer qt.Recovering("QLineF::fromPolar")
|
|
|
|
return NewQLineFFromPointer(C.QLineF_QLineF_FromPolar(C.double(length), C.double(angle)))
|
|
}
|
|
|
|
func (ptr *QLineF) IsNull() bool {
|
|
defer qt.Recovering("QLineF::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLineF_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLineF) Length() float64 {
|
|
defer qt.Recovering("QLineF::length")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QLineF_Length(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLineF) NormalVector() *QLineF {
|
|
defer qt.Recovering("QLineF::normalVector")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLineFFromPointer(C.QLineF_NormalVector(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLineF) P1() *QPointF {
|
|
defer qt.Recovering("QLineF::p1")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFFromPointer(C.QLineF_P1(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLineF) P2() *QPointF {
|
|
defer qt.Recovering("QLineF::p2")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFFromPointer(C.QLineF_P2(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLineF) PointAt(t float64) *QPointF {
|
|
defer qt.Recovering("QLineF::pointAt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFFromPointer(C.QLineF_PointAt(ptr.Pointer(), C.double(t)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLineF) SetAngle(angle float64) {
|
|
defer qt.Recovering("QLineF::setAngle")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLineF_SetAngle(ptr.Pointer(), C.double(angle))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLineF) SetLength(length float64) {
|
|
defer qt.Recovering("QLineF::setLength")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLineF_SetLength(ptr.Pointer(), C.double(length))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLineF) SetLine(x1 float64, y1 float64, x2 float64, y2 float64) {
|
|
defer qt.Recovering("QLineF::setLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLineF_SetLine(ptr.Pointer(), C.double(x1), C.double(y1), C.double(x2), C.double(y2))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLineF) SetP1(p1 QPointF_ITF) {
|
|
defer qt.Recovering("QLineF::setP1")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLineF_SetP1(ptr.Pointer(), PointerFromQPointF(p1))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLineF) SetP2(p2 QPointF_ITF) {
|
|
defer qt.Recovering("QLineF::setP2")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLineF_SetP2(ptr.Pointer(), PointerFromQPointF(p2))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLineF) SetPoints(p1 QPointF_ITF, p2 QPointF_ITF) {
|
|
defer qt.Recovering("QLineF::setPoints")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLineF_SetPoints(ptr.Pointer(), PointerFromQPointF(p1), PointerFromQPointF(p2))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLineF) ToLine() *QLine {
|
|
defer qt.Recovering("QLineF::toLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLineFromPointer(C.QLineF_ToLine(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLineF) Translate(offset QPointF_ITF) {
|
|
defer qt.Recovering("QLineF::translate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLineF_Translate(ptr.Pointer(), PointerFromQPointF(offset))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLineF) Translate2(dx float64, dy float64) {
|
|
defer qt.Recovering("QLineF::translate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLineF_Translate2(ptr.Pointer(), C.double(dx), C.double(dy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLineF) Translated(offset QPointF_ITF) *QLineF {
|
|
defer qt.Recovering("QLineF::translated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLineFFromPointer(C.QLineF_Translated(ptr.Pointer(), PointerFromQPointF(offset)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLineF) Translated2(dx float64, dy float64) *QLineF {
|
|
defer qt.Recovering("QLineF::translated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLineFFromPointer(C.QLineF_Translated2(ptr.Pointer(), C.double(dx), C.double(dy)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLineF) UnitVector() *QLineF {
|
|
defer qt.Recovering("QLineF::unitVector")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLineFFromPointer(C.QLineF_UnitVector(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLineF) X1() float64 {
|
|
defer qt.Recovering("QLineF::x1")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QLineF_X1(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLineF) X2() float64 {
|
|
defer qt.Recovering("QLineF::x2")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QLineF_X2(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLineF) Y1() float64 {
|
|
defer qt.Recovering("QLineF::y1")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QLineF_Y1(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLineF) Y2() float64 {
|
|
defer qt.Recovering("QLineF::y2")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QLineF_Y2(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QLinkedList struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QLinkedList_ITF interface {
|
|
QLinkedList_PTR() *QLinkedList
|
|
}
|
|
|
|
func (p *QLinkedList) QLinkedList_PTR() *QLinkedList {
|
|
return p
|
|
}
|
|
|
|
func (p *QLinkedList) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QLinkedList) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQLinkedList(ptr QLinkedList_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QLinkedList_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQLinkedListFromPointer(ptr unsafe.Pointer) *QLinkedList {
|
|
var n = new(QLinkedList)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQLinkedListFromPointer(ptr unsafe.Pointer) *QLinkedList {
|
|
var n = NewQLinkedListFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QLinkedListIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QLinkedListIterator_ITF interface {
|
|
QLinkedListIterator_PTR() *QLinkedListIterator
|
|
}
|
|
|
|
func (p *QLinkedListIterator) QLinkedListIterator_PTR() *QLinkedListIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QLinkedListIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QLinkedListIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQLinkedListIterator(ptr QLinkedListIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QLinkedListIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQLinkedListIteratorFromPointer(ptr unsafe.Pointer) *QLinkedListIterator {
|
|
var n = new(QLinkedListIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQLinkedListIteratorFromPointer(ptr unsafe.Pointer) *QLinkedListIterator {
|
|
var n = NewQLinkedListIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QList struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QList_ITF interface {
|
|
QList_PTR() *QList
|
|
}
|
|
|
|
func (p *QList) QList_PTR() *QList {
|
|
return p
|
|
}
|
|
|
|
func (p *QList) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QList) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQList(ptr QList_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QList_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQListFromPointer(ptr unsafe.Pointer) *QList {
|
|
var n = new(QList)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQListFromPointer(ptr unsafe.Pointer) *QList {
|
|
var n = NewQListFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QListIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QListIterator_ITF interface {
|
|
QListIterator_PTR() *QListIterator
|
|
}
|
|
|
|
func (p *QListIterator) QListIterator_PTR() *QListIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QListIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QListIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQListIterator(ptr QListIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QListIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQListIteratorFromPointer(ptr unsafe.Pointer) *QListIterator {
|
|
var n = new(QListIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQListIteratorFromPointer(ptr unsafe.Pointer) *QListIterator {
|
|
var n = NewQListIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QLocale::Country
|
|
type QLocale__Country int64
|
|
|
|
const (
|
|
QLocale__AnyCountry = QLocale__Country(0)
|
|
QLocale__Afghanistan = QLocale__Country(1)
|
|
QLocale__Albania = QLocale__Country(2)
|
|
QLocale__Algeria = QLocale__Country(3)
|
|
QLocale__AmericanSamoa = QLocale__Country(4)
|
|
QLocale__Andorra = QLocale__Country(5)
|
|
QLocale__Angola = QLocale__Country(6)
|
|
QLocale__Anguilla = QLocale__Country(7)
|
|
QLocale__Antarctica = QLocale__Country(8)
|
|
QLocale__AntiguaAndBarbuda = QLocale__Country(9)
|
|
QLocale__Argentina = QLocale__Country(10)
|
|
QLocale__Armenia = QLocale__Country(11)
|
|
QLocale__Aruba = QLocale__Country(12)
|
|
QLocale__Australia = QLocale__Country(13)
|
|
QLocale__Austria = QLocale__Country(14)
|
|
QLocale__Azerbaijan = QLocale__Country(15)
|
|
QLocale__Bahamas = QLocale__Country(16)
|
|
QLocale__Bahrain = QLocale__Country(17)
|
|
QLocale__Bangladesh = QLocale__Country(18)
|
|
QLocale__Barbados = QLocale__Country(19)
|
|
QLocale__Belarus = QLocale__Country(20)
|
|
QLocale__Belgium = QLocale__Country(21)
|
|
QLocale__Belize = QLocale__Country(22)
|
|
QLocale__Benin = QLocale__Country(23)
|
|
QLocale__Bermuda = QLocale__Country(24)
|
|
QLocale__Bhutan = QLocale__Country(25)
|
|
QLocale__Bolivia = QLocale__Country(26)
|
|
QLocale__BosniaAndHerzegowina = QLocale__Country(27)
|
|
QLocale__Botswana = QLocale__Country(28)
|
|
QLocale__BouvetIsland = QLocale__Country(29)
|
|
QLocale__Brazil = QLocale__Country(30)
|
|
QLocale__BritishIndianOceanTerritory = QLocale__Country(31)
|
|
QLocale__Brunei = QLocale__Country(32)
|
|
QLocale__Bulgaria = QLocale__Country(33)
|
|
QLocale__BurkinaFaso = QLocale__Country(34)
|
|
QLocale__Burundi = QLocale__Country(35)
|
|
QLocale__Cambodia = QLocale__Country(36)
|
|
QLocale__Cameroon = QLocale__Country(37)
|
|
QLocale__Canada = QLocale__Country(38)
|
|
QLocale__CapeVerde = QLocale__Country(39)
|
|
QLocale__CaymanIslands = QLocale__Country(40)
|
|
QLocale__CentralAfricanRepublic = QLocale__Country(41)
|
|
QLocale__Chad = QLocale__Country(42)
|
|
QLocale__Chile = QLocale__Country(43)
|
|
QLocale__China = QLocale__Country(44)
|
|
QLocale__ChristmasIsland = QLocale__Country(45)
|
|
QLocale__CocosIslands = QLocale__Country(46)
|
|
QLocale__Colombia = QLocale__Country(47)
|
|
QLocale__Comoros = QLocale__Country(48)
|
|
QLocale__CongoKinshasa = QLocale__Country(49)
|
|
QLocale__CongoBrazzaville = QLocale__Country(50)
|
|
QLocale__CookIslands = QLocale__Country(51)
|
|
QLocale__CostaRica = QLocale__Country(52)
|
|
QLocale__IvoryCoast = QLocale__Country(53)
|
|
QLocale__Croatia = QLocale__Country(54)
|
|
QLocale__Cuba = QLocale__Country(55)
|
|
QLocale__Cyprus = QLocale__Country(56)
|
|
QLocale__CzechRepublic = QLocale__Country(57)
|
|
QLocale__Denmark = QLocale__Country(58)
|
|
QLocale__Djibouti = QLocale__Country(59)
|
|
QLocale__Dominica = QLocale__Country(60)
|
|
QLocale__DominicanRepublic = QLocale__Country(61)
|
|
QLocale__EastTimor = QLocale__Country(62)
|
|
QLocale__Ecuador = QLocale__Country(63)
|
|
QLocale__Egypt = QLocale__Country(64)
|
|
QLocale__ElSalvador = QLocale__Country(65)
|
|
QLocale__EquatorialGuinea = QLocale__Country(66)
|
|
QLocale__Eritrea = QLocale__Country(67)
|
|
QLocale__Estonia = QLocale__Country(68)
|
|
QLocale__Ethiopia = QLocale__Country(69)
|
|
QLocale__FalklandIslands = QLocale__Country(70)
|
|
QLocale__FaroeIslands = QLocale__Country(71)
|
|
QLocale__Fiji = QLocale__Country(72)
|
|
QLocale__Finland = QLocale__Country(73)
|
|
QLocale__France = QLocale__Country(74)
|
|
QLocale__Guernsey = QLocale__Country(75)
|
|
QLocale__FrenchGuiana = QLocale__Country(76)
|
|
QLocale__FrenchPolynesia = QLocale__Country(77)
|
|
QLocale__FrenchSouthernTerritories = QLocale__Country(78)
|
|
QLocale__Gabon = QLocale__Country(79)
|
|
QLocale__Gambia = QLocale__Country(80)
|
|
QLocale__Georgia = QLocale__Country(81)
|
|
QLocale__Germany = QLocale__Country(82)
|
|
QLocale__Ghana = QLocale__Country(83)
|
|
QLocale__Gibraltar = QLocale__Country(84)
|
|
QLocale__Greece = QLocale__Country(85)
|
|
QLocale__Greenland = QLocale__Country(86)
|
|
QLocale__Grenada = QLocale__Country(87)
|
|
QLocale__Guadeloupe = QLocale__Country(88)
|
|
QLocale__Guam = QLocale__Country(89)
|
|
QLocale__Guatemala = QLocale__Country(90)
|
|
QLocale__Guinea = QLocale__Country(91)
|
|
QLocale__GuineaBissau = QLocale__Country(92)
|
|
QLocale__Guyana = QLocale__Country(93)
|
|
QLocale__Haiti = QLocale__Country(94)
|
|
QLocale__HeardAndMcDonaldIslands = QLocale__Country(95)
|
|
QLocale__Honduras = QLocale__Country(96)
|
|
QLocale__HongKong = QLocale__Country(97)
|
|
QLocale__Hungary = QLocale__Country(98)
|
|
QLocale__Iceland = QLocale__Country(99)
|
|
QLocale__India = QLocale__Country(100)
|
|
QLocale__Indonesia = QLocale__Country(101)
|
|
QLocale__Iran = QLocale__Country(102)
|
|
QLocale__Iraq = QLocale__Country(103)
|
|
QLocale__Ireland = QLocale__Country(104)
|
|
QLocale__Israel = QLocale__Country(105)
|
|
QLocale__Italy = QLocale__Country(106)
|
|
QLocale__Jamaica = QLocale__Country(107)
|
|
QLocale__Japan = QLocale__Country(108)
|
|
QLocale__Jordan = QLocale__Country(109)
|
|
QLocale__Kazakhstan = QLocale__Country(110)
|
|
QLocale__Kenya = QLocale__Country(111)
|
|
QLocale__Kiribati = QLocale__Country(112)
|
|
QLocale__NorthKorea = QLocale__Country(113)
|
|
QLocale__SouthKorea = QLocale__Country(114)
|
|
QLocale__Kuwait = QLocale__Country(115)
|
|
QLocale__Kyrgyzstan = QLocale__Country(116)
|
|
QLocale__Laos = QLocale__Country(117)
|
|
QLocale__Latvia = QLocale__Country(118)
|
|
QLocale__Lebanon = QLocale__Country(119)
|
|
QLocale__Lesotho = QLocale__Country(120)
|
|
QLocale__Liberia = QLocale__Country(121)
|
|
QLocale__Libya = QLocale__Country(122)
|
|
QLocale__Liechtenstein = QLocale__Country(123)
|
|
QLocale__Lithuania = QLocale__Country(124)
|
|
QLocale__Luxembourg = QLocale__Country(125)
|
|
QLocale__Macau = QLocale__Country(126)
|
|
QLocale__Macedonia = QLocale__Country(127)
|
|
QLocale__Madagascar = QLocale__Country(128)
|
|
QLocale__Malawi = QLocale__Country(129)
|
|
QLocale__Malaysia = QLocale__Country(130)
|
|
QLocale__Maldives = QLocale__Country(131)
|
|
QLocale__Mali = QLocale__Country(132)
|
|
QLocale__Malta = QLocale__Country(133)
|
|
QLocale__MarshallIslands = QLocale__Country(134)
|
|
QLocale__Martinique = QLocale__Country(135)
|
|
QLocale__Mauritania = QLocale__Country(136)
|
|
QLocale__Mauritius = QLocale__Country(137)
|
|
QLocale__Mayotte = QLocale__Country(138)
|
|
QLocale__Mexico = QLocale__Country(139)
|
|
QLocale__Micronesia = QLocale__Country(140)
|
|
QLocale__Moldova = QLocale__Country(141)
|
|
QLocale__Monaco = QLocale__Country(142)
|
|
QLocale__Mongolia = QLocale__Country(143)
|
|
QLocale__Montserrat = QLocale__Country(144)
|
|
QLocale__Morocco = QLocale__Country(145)
|
|
QLocale__Mozambique = QLocale__Country(146)
|
|
QLocale__Myanmar = QLocale__Country(147)
|
|
QLocale__Namibia = QLocale__Country(148)
|
|
QLocale__NauruCountry = QLocale__Country(149)
|
|
QLocale__Nepal = QLocale__Country(150)
|
|
QLocale__Netherlands = QLocale__Country(151)
|
|
QLocale__CuraSao = QLocale__Country(152)
|
|
QLocale__NewCaledonia = QLocale__Country(153)
|
|
QLocale__NewZealand = QLocale__Country(154)
|
|
QLocale__Nicaragua = QLocale__Country(155)
|
|
QLocale__Niger = QLocale__Country(156)
|
|
QLocale__Nigeria = QLocale__Country(157)
|
|
QLocale__Niue = QLocale__Country(158)
|
|
QLocale__NorfolkIsland = QLocale__Country(159)
|
|
QLocale__NorthernMarianaIslands = QLocale__Country(160)
|
|
QLocale__Norway = QLocale__Country(161)
|
|
QLocale__Oman = QLocale__Country(162)
|
|
QLocale__Pakistan = QLocale__Country(163)
|
|
QLocale__Palau = QLocale__Country(164)
|
|
QLocale__PalestinianTerritories = QLocale__Country(165)
|
|
QLocale__Panama = QLocale__Country(166)
|
|
QLocale__PapuaNewGuinea = QLocale__Country(167)
|
|
QLocale__Paraguay = QLocale__Country(168)
|
|
QLocale__Peru = QLocale__Country(169)
|
|
QLocale__Philippines = QLocale__Country(170)
|
|
QLocale__Pitcairn = QLocale__Country(171)
|
|
QLocale__Poland = QLocale__Country(172)
|
|
QLocale__Portugal = QLocale__Country(173)
|
|
QLocale__PuertoRico = QLocale__Country(174)
|
|
QLocale__Qatar = QLocale__Country(175)
|
|
QLocale__Reunion = QLocale__Country(176)
|
|
QLocale__Romania = QLocale__Country(177)
|
|
QLocale__Russia = QLocale__Country(178)
|
|
QLocale__Rwanda = QLocale__Country(179)
|
|
QLocale__SaintKittsAndNevis = QLocale__Country(180)
|
|
QLocale__SaintLucia = QLocale__Country(181)
|
|
QLocale__SaintVincentAndTheGrenadines = QLocale__Country(182)
|
|
QLocale__Samoa = QLocale__Country(183)
|
|
QLocale__SanMarino = QLocale__Country(184)
|
|
QLocale__SaoTomeAndPrincipe = QLocale__Country(185)
|
|
QLocale__SaudiArabia = QLocale__Country(186)
|
|
QLocale__Senegal = QLocale__Country(187)
|
|
QLocale__Seychelles = QLocale__Country(188)
|
|
QLocale__SierraLeone = QLocale__Country(189)
|
|
QLocale__Singapore = QLocale__Country(190)
|
|
QLocale__Slovakia = QLocale__Country(191)
|
|
QLocale__Slovenia = QLocale__Country(192)
|
|
QLocale__SolomonIslands = QLocale__Country(193)
|
|
QLocale__Somalia = QLocale__Country(194)
|
|
QLocale__SouthAfrica = QLocale__Country(195)
|
|
QLocale__SouthGeorgiaAndTheSouthSandwichIslands = QLocale__Country(196)
|
|
QLocale__Spain = QLocale__Country(197)
|
|
QLocale__SriLanka = QLocale__Country(198)
|
|
QLocale__SaintHelena = QLocale__Country(199)
|
|
QLocale__SaintPierreAndMiquelon = QLocale__Country(200)
|
|
QLocale__Sudan = QLocale__Country(201)
|
|
QLocale__Suriname = QLocale__Country(202)
|
|
QLocale__SvalbardAndJanMayenIslands = QLocale__Country(203)
|
|
QLocale__Swaziland = QLocale__Country(204)
|
|
QLocale__Sweden = QLocale__Country(205)
|
|
QLocale__Switzerland = QLocale__Country(206)
|
|
QLocale__Syria = QLocale__Country(207)
|
|
QLocale__Taiwan = QLocale__Country(208)
|
|
QLocale__Tajikistan = QLocale__Country(209)
|
|
QLocale__Tanzania = QLocale__Country(210)
|
|
QLocale__Thailand = QLocale__Country(211)
|
|
QLocale__Togo = QLocale__Country(212)
|
|
QLocale__Tokelau = QLocale__Country(213)
|
|
QLocale__Tonga = QLocale__Country(214)
|
|
QLocale__TrinidadAndTobago = QLocale__Country(215)
|
|
QLocale__Tunisia = QLocale__Country(216)
|
|
QLocale__Turkey = QLocale__Country(217)
|
|
QLocale__Turkmenistan = QLocale__Country(218)
|
|
QLocale__TurksAndCaicosIslands = QLocale__Country(219)
|
|
QLocale__Tuvalu = QLocale__Country(220)
|
|
QLocale__Uganda = QLocale__Country(221)
|
|
QLocale__Ukraine = QLocale__Country(222)
|
|
QLocale__UnitedArabEmirates = QLocale__Country(223)
|
|
QLocale__UnitedKingdom = QLocale__Country(224)
|
|
QLocale__UnitedStates = QLocale__Country(225)
|
|
QLocale__UnitedStatesMinorOutlyingIslands = QLocale__Country(226)
|
|
QLocale__Uruguay = QLocale__Country(227)
|
|
QLocale__Uzbekistan = QLocale__Country(228)
|
|
QLocale__Vanuatu = QLocale__Country(229)
|
|
QLocale__VaticanCityState = QLocale__Country(230)
|
|
QLocale__Venezuela = QLocale__Country(231)
|
|
QLocale__Vietnam = QLocale__Country(232)
|
|
QLocale__BritishVirginIslands = QLocale__Country(233)
|
|
QLocale__UnitedStatesVirginIslands = QLocale__Country(234)
|
|
QLocale__WallisAndFutunaIslands = QLocale__Country(235)
|
|
QLocale__WesternSahara = QLocale__Country(236)
|
|
QLocale__Yemen = QLocale__Country(237)
|
|
QLocale__CanaryIslands = QLocale__Country(238)
|
|
QLocale__Zambia = QLocale__Country(239)
|
|
QLocale__Zimbabwe = QLocale__Country(240)
|
|
QLocale__ClippertonIsland = QLocale__Country(241)
|
|
QLocale__Montenegro = QLocale__Country(242)
|
|
QLocale__Serbia = QLocale__Country(243)
|
|
QLocale__SaintBarthelemy = QLocale__Country(244)
|
|
QLocale__SaintMartin = QLocale__Country(245)
|
|
QLocale__LatinAmericaAndTheCaribbean = QLocale__Country(246)
|
|
QLocale__AscensionIsland = QLocale__Country(247)
|
|
QLocale__AlandIslands = QLocale__Country(248)
|
|
QLocale__DiegoGarcia = QLocale__Country(249)
|
|
QLocale__CeutaAndMelilla = QLocale__Country(250)
|
|
QLocale__IsleOfMan = QLocale__Country(251)
|
|
QLocale__Jersey = QLocale__Country(252)
|
|
QLocale__TristanDaCunha = QLocale__Country(253)
|
|
QLocale__SouthSudan = QLocale__Country(254)
|
|
QLocale__Bonaire = QLocale__Country(255)
|
|
QLocale__SintMaarten = QLocale__Country(256)
|
|
QLocale__Kosovo = QLocale__Country(257)
|
|
QLocale__DemocraticRepublicOfCongo = QLocale__Country(QLocale__CongoKinshasa)
|
|
QLocale__PeoplesRepublicOfCongo = QLocale__Country(QLocale__CongoBrazzaville)
|
|
QLocale__DemocraticRepublicOfKorea = QLocale__Country(QLocale__NorthKorea)
|
|
QLocale__RepublicOfKorea = QLocale__Country(QLocale__SouthKorea)
|
|
QLocale__RussianFederation = QLocale__Country(QLocale__Russia)
|
|
QLocale__SyrianArabRepublic = QLocale__Country(QLocale__Syria)
|
|
QLocale__LastCountry = QLocale__Country(QLocale__Kosovo)
|
|
)
|
|
|
|
//QLocale::CurrencySymbolFormat
|
|
type QLocale__CurrencySymbolFormat int64
|
|
|
|
const (
|
|
QLocale__CurrencyIsoCode = QLocale__CurrencySymbolFormat(0)
|
|
QLocale__CurrencySymbol = QLocale__CurrencySymbolFormat(1)
|
|
QLocale__CurrencyDisplayName = QLocale__CurrencySymbolFormat(2)
|
|
)
|
|
|
|
//QLocale::FormatType
|
|
type QLocale__FormatType int64
|
|
|
|
const (
|
|
QLocale__LongFormat = QLocale__FormatType(0)
|
|
QLocale__ShortFormat = QLocale__FormatType(1)
|
|
QLocale__NarrowFormat = QLocale__FormatType(2)
|
|
)
|
|
|
|
//QLocale::Language
|
|
type QLocale__Language int64
|
|
|
|
const (
|
|
QLocale__AnyLanguage = QLocale__Language(0)
|
|
QLocale__C = QLocale__Language(1)
|
|
QLocale__Abkhazian = QLocale__Language(2)
|
|
QLocale__Oromo = QLocale__Language(3)
|
|
QLocale__Afar = QLocale__Language(4)
|
|
QLocale__Afrikaans = QLocale__Language(5)
|
|
QLocale__Albanian = QLocale__Language(6)
|
|
QLocale__Amharic = QLocale__Language(7)
|
|
QLocale__Arabic = QLocale__Language(8)
|
|
QLocale__Armenian = QLocale__Language(9)
|
|
QLocale__Assamese = QLocale__Language(10)
|
|
QLocale__Aymara = QLocale__Language(11)
|
|
QLocale__Azerbaijani = QLocale__Language(12)
|
|
QLocale__Bashkir = QLocale__Language(13)
|
|
QLocale__Basque = QLocale__Language(14)
|
|
QLocale__Bengali = QLocale__Language(15)
|
|
QLocale__Dzongkha = QLocale__Language(16)
|
|
QLocale__Bihari = QLocale__Language(17)
|
|
QLocale__Bislama = QLocale__Language(18)
|
|
QLocale__Breton = QLocale__Language(19)
|
|
QLocale__Bulgarian = QLocale__Language(20)
|
|
QLocale__Burmese = QLocale__Language(21)
|
|
QLocale__Belarusian = QLocale__Language(22)
|
|
QLocale__Khmer = QLocale__Language(23)
|
|
QLocale__Catalan = QLocale__Language(24)
|
|
QLocale__Chinese = QLocale__Language(25)
|
|
QLocale__Corsican = QLocale__Language(26)
|
|
QLocale__Croatian = QLocale__Language(27)
|
|
QLocale__Czech = QLocale__Language(28)
|
|
QLocale__Danish = QLocale__Language(29)
|
|
QLocale__Dutch = QLocale__Language(30)
|
|
QLocale__English = QLocale__Language(31)
|
|
QLocale__Esperanto = QLocale__Language(32)
|
|
QLocale__Estonian = QLocale__Language(33)
|
|
QLocale__Faroese = QLocale__Language(34)
|
|
QLocale__Fijian = QLocale__Language(35)
|
|
QLocale__Finnish = QLocale__Language(36)
|
|
QLocale__French = QLocale__Language(37)
|
|
QLocale__WesternFrisian = QLocale__Language(38)
|
|
QLocale__Gaelic = QLocale__Language(39)
|
|
QLocale__Galician = QLocale__Language(40)
|
|
QLocale__Georgian = QLocale__Language(41)
|
|
QLocale__German = QLocale__Language(42)
|
|
QLocale__Greek = QLocale__Language(43)
|
|
QLocale__Greenlandic = QLocale__Language(44)
|
|
QLocale__Guarani = QLocale__Language(45)
|
|
QLocale__Gujarati = QLocale__Language(46)
|
|
QLocale__Hausa = QLocale__Language(47)
|
|
QLocale__Hebrew = QLocale__Language(48)
|
|
QLocale__Hindi = QLocale__Language(49)
|
|
QLocale__Hungarian = QLocale__Language(50)
|
|
QLocale__Icelandic = QLocale__Language(51)
|
|
QLocale__Indonesian = QLocale__Language(52)
|
|
QLocale__Interlingua = QLocale__Language(53)
|
|
QLocale__Interlingue = QLocale__Language(54)
|
|
QLocale__Inuktitut = QLocale__Language(55)
|
|
QLocale__Inupiak = QLocale__Language(56)
|
|
QLocale__Irish = QLocale__Language(57)
|
|
QLocale__Italian = QLocale__Language(58)
|
|
QLocale__Japanese = QLocale__Language(59)
|
|
QLocale__Javanese = QLocale__Language(60)
|
|
QLocale__Kannada = QLocale__Language(61)
|
|
QLocale__Kashmiri = QLocale__Language(62)
|
|
QLocale__Kazakh = QLocale__Language(63)
|
|
QLocale__Kinyarwanda = QLocale__Language(64)
|
|
QLocale__Kirghiz = QLocale__Language(65)
|
|
QLocale__Korean = QLocale__Language(66)
|
|
QLocale__Kurdish = QLocale__Language(67)
|
|
QLocale__Rundi = QLocale__Language(68)
|
|
QLocale__Lao = QLocale__Language(69)
|
|
QLocale__Latin = QLocale__Language(70)
|
|
QLocale__Latvian = QLocale__Language(71)
|
|
QLocale__Lingala = QLocale__Language(72)
|
|
QLocale__Lithuanian = QLocale__Language(73)
|
|
QLocale__Macedonian = QLocale__Language(74)
|
|
QLocale__Malagasy = QLocale__Language(75)
|
|
QLocale__Malay = QLocale__Language(76)
|
|
QLocale__Malayalam = QLocale__Language(77)
|
|
QLocale__Maltese = QLocale__Language(78)
|
|
QLocale__Maori = QLocale__Language(79)
|
|
QLocale__Marathi = QLocale__Language(80)
|
|
QLocale__Marshallese = QLocale__Language(81)
|
|
QLocale__Mongolian = QLocale__Language(82)
|
|
QLocale__NauruLanguage = QLocale__Language(83)
|
|
QLocale__Nepali = QLocale__Language(84)
|
|
QLocale__NorwegianBokmal = QLocale__Language(85)
|
|
QLocale__Occitan = QLocale__Language(86)
|
|
QLocale__Oriya = QLocale__Language(87)
|
|
QLocale__Pashto = QLocale__Language(88)
|
|
QLocale__Persian = QLocale__Language(89)
|
|
QLocale__Polish = QLocale__Language(90)
|
|
QLocale__Portuguese = QLocale__Language(91)
|
|
QLocale__Punjabi = QLocale__Language(92)
|
|
QLocale__Quechua = QLocale__Language(93)
|
|
QLocale__Romansh = QLocale__Language(94)
|
|
QLocale__Romanian = QLocale__Language(95)
|
|
QLocale__Russian = QLocale__Language(96)
|
|
QLocale__Samoan = QLocale__Language(97)
|
|
QLocale__Sango = QLocale__Language(98)
|
|
QLocale__Sanskrit = QLocale__Language(99)
|
|
QLocale__Serbian = QLocale__Language(100)
|
|
QLocale__Ossetic = QLocale__Language(101)
|
|
QLocale__SouthernSotho = QLocale__Language(102)
|
|
QLocale__Tswana = QLocale__Language(103)
|
|
QLocale__Shona = QLocale__Language(104)
|
|
QLocale__Sindhi = QLocale__Language(105)
|
|
QLocale__Sinhala = QLocale__Language(106)
|
|
QLocale__Swati = QLocale__Language(107)
|
|
QLocale__Slovak = QLocale__Language(108)
|
|
QLocale__Slovenian = QLocale__Language(109)
|
|
QLocale__Somali = QLocale__Language(110)
|
|
QLocale__Spanish = QLocale__Language(111)
|
|
QLocale__Sundanese = QLocale__Language(112)
|
|
QLocale__Swahili = QLocale__Language(113)
|
|
QLocale__Swedish = QLocale__Language(114)
|
|
QLocale__Sardinian = QLocale__Language(115)
|
|
QLocale__Tajik = QLocale__Language(116)
|
|
QLocale__Tamil = QLocale__Language(117)
|
|
QLocale__Tatar = QLocale__Language(118)
|
|
QLocale__Telugu = QLocale__Language(119)
|
|
QLocale__Thai = QLocale__Language(120)
|
|
QLocale__Tibetan = QLocale__Language(121)
|
|
QLocale__Tigrinya = QLocale__Language(122)
|
|
QLocale__Tongan = QLocale__Language(123)
|
|
QLocale__Tsonga = QLocale__Language(124)
|
|
QLocale__Turkish = QLocale__Language(125)
|
|
QLocale__Turkmen = QLocale__Language(126)
|
|
QLocale__Tahitian = QLocale__Language(127)
|
|
QLocale__Uighur = QLocale__Language(128)
|
|
QLocale__Ukrainian = QLocale__Language(129)
|
|
QLocale__Urdu = QLocale__Language(130)
|
|
QLocale__Uzbek = QLocale__Language(131)
|
|
QLocale__Vietnamese = QLocale__Language(132)
|
|
QLocale__Volapuk = QLocale__Language(133)
|
|
QLocale__Welsh = QLocale__Language(134)
|
|
QLocale__Wolof = QLocale__Language(135)
|
|
QLocale__Xhosa = QLocale__Language(136)
|
|
QLocale__Yiddish = QLocale__Language(137)
|
|
QLocale__Yoruba = QLocale__Language(138)
|
|
QLocale__Zhuang = QLocale__Language(139)
|
|
QLocale__Zulu = QLocale__Language(140)
|
|
QLocale__NorwegianNynorsk = QLocale__Language(141)
|
|
QLocale__Bosnian = QLocale__Language(142)
|
|
QLocale__Divehi = QLocale__Language(143)
|
|
QLocale__Manx = QLocale__Language(144)
|
|
QLocale__Cornish = QLocale__Language(145)
|
|
QLocale__Akan = QLocale__Language(146)
|
|
QLocale__Konkani = QLocale__Language(147)
|
|
QLocale__Ga = QLocale__Language(148)
|
|
QLocale__Igbo = QLocale__Language(149)
|
|
QLocale__Kamba = QLocale__Language(150)
|
|
QLocale__Syriac = QLocale__Language(151)
|
|
QLocale__Blin = QLocale__Language(152)
|
|
QLocale__Geez = QLocale__Language(153)
|
|
QLocale__Koro = QLocale__Language(154)
|
|
QLocale__Sidamo = QLocale__Language(155)
|
|
QLocale__Atsam = QLocale__Language(156)
|
|
QLocale__Tigre = QLocale__Language(157)
|
|
QLocale__Jju = QLocale__Language(158)
|
|
QLocale__Friulian = QLocale__Language(159)
|
|
QLocale__Venda = QLocale__Language(160)
|
|
QLocale__Ewe = QLocale__Language(161)
|
|
QLocale__Walamo = QLocale__Language(162)
|
|
QLocale__Hawaiian = QLocale__Language(163)
|
|
QLocale__Tyap = QLocale__Language(164)
|
|
QLocale__Nyanja = QLocale__Language(165)
|
|
QLocale__Filipino = QLocale__Language(166)
|
|
QLocale__SwissGerman = QLocale__Language(167)
|
|
QLocale__SichuanYi = QLocale__Language(168)
|
|
QLocale__Kpelle = QLocale__Language(169)
|
|
QLocale__LowGerman = QLocale__Language(170)
|
|
QLocale__SouthNdebele = QLocale__Language(171)
|
|
QLocale__NorthernSotho = QLocale__Language(172)
|
|
QLocale__NorthernSami = QLocale__Language(173)
|
|
QLocale__Taroko = QLocale__Language(174)
|
|
QLocale__Gusii = QLocale__Language(175)
|
|
QLocale__Taita = QLocale__Language(176)
|
|
QLocale__Fulah = QLocale__Language(177)
|
|
QLocale__Kikuyu = QLocale__Language(178)
|
|
QLocale__Samburu = QLocale__Language(179)
|
|
QLocale__Sena = QLocale__Language(180)
|
|
QLocale__NorthNdebele = QLocale__Language(181)
|
|
QLocale__Rombo = QLocale__Language(182)
|
|
QLocale__Tachelhit = QLocale__Language(183)
|
|
QLocale__Kabyle = QLocale__Language(184)
|
|
QLocale__Nyankole = QLocale__Language(185)
|
|
QLocale__Bena = QLocale__Language(186)
|
|
QLocale__Vunjo = QLocale__Language(187)
|
|
QLocale__Bambara = QLocale__Language(188)
|
|
QLocale__Embu = QLocale__Language(189)
|
|
QLocale__Cherokee = QLocale__Language(190)
|
|
QLocale__Morisyen = QLocale__Language(191)
|
|
QLocale__Makonde = QLocale__Language(192)
|
|
QLocale__Langi = QLocale__Language(193)
|
|
QLocale__Ganda = QLocale__Language(194)
|
|
QLocale__Bemba = QLocale__Language(195)
|
|
QLocale__Kabuverdianu = QLocale__Language(196)
|
|
QLocale__Meru = QLocale__Language(197)
|
|
QLocale__Kalenjin = QLocale__Language(198)
|
|
QLocale__Nama = QLocale__Language(199)
|
|
QLocale__Machame = QLocale__Language(200)
|
|
QLocale__Colognian = QLocale__Language(201)
|
|
QLocale__Masai = QLocale__Language(202)
|
|
QLocale__Soga = QLocale__Language(203)
|
|
QLocale__Luyia = QLocale__Language(204)
|
|
QLocale__Asu = QLocale__Language(205)
|
|
QLocale__Teso = QLocale__Language(206)
|
|
QLocale__Saho = QLocale__Language(207)
|
|
QLocale__KoyraChiini = QLocale__Language(208)
|
|
QLocale__Rwa = QLocale__Language(209)
|
|
QLocale__Luo = QLocale__Language(210)
|
|
QLocale__Chiga = QLocale__Language(211)
|
|
QLocale__CentralMoroccoTamazight = QLocale__Language(212)
|
|
QLocale__KoyraboroSenni = QLocale__Language(213)
|
|
QLocale__Shambala = QLocale__Language(214)
|
|
QLocale__Bodo = QLocale__Language(215)
|
|
QLocale__Avaric = QLocale__Language(216)
|
|
QLocale__Chamorro = QLocale__Language(217)
|
|
QLocale__Chechen = QLocale__Language(218)
|
|
QLocale__Church = QLocale__Language(219)
|
|
QLocale__Chuvash = QLocale__Language(220)
|
|
QLocale__Cree = QLocale__Language(221)
|
|
QLocale__Haitian = QLocale__Language(222)
|
|
QLocale__Herero = QLocale__Language(223)
|
|
QLocale__HiriMotu = QLocale__Language(224)
|
|
QLocale__Kanuri = QLocale__Language(225)
|
|
QLocale__Komi = QLocale__Language(226)
|
|
QLocale__Kongo = QLocale__Language(227)
|
|
QLocale__Kwanyama = QLocale__Language(228)
|
|
QLocale__Limburgish = QLocale__Language(229)
|
|
QLocale__LubaKatanga = QLocale__Language(230)
|
|
QLocale__Luxembourgish = QLocale__Language(231)
|
|
QLocale__Navaho = QLocale__Language(232)
|
|
QLocale__Ndonga = QLocale__Language(233)
|
|
QLocale__Ojibwa = QLocale__Language(234)
|
|
QLocale__Pali = QLocale__Language(235)
|
|
QLocale__Walloon = QLocale__Language(236)
|
|
QLocale__Aghem = QLocale__Language(237)
|
|
QLocale__Basaa = QLocale__Language(238)
|
|
QLocale__Zarma = QLocale__Language(239)
|
|
QLocale__Duala = QLocale__Language(240)
|
|
QLocale__JolaFonyi = QLocale__Language(241)
|
|
QLocale__Ewondo = QLocale__Language(242)
|
|
QLocale__Bafia = QLocale__Language(243)
|
|
QLocale__MakhuwaMeetto = QLocale__Language(244)
|
|
QLocale__Mundang = QLocale__Language(245)
|
|
QLocale__Kwasio = QLocale__Language(246)
|
|
QLocale__Nuer = QLocale__Language(247)
|
|
QLocale__Sakha = QLocale__Language(248)
|
|
QLocale__Sangu = QLocale__Language(249)
|
|
QLocale__CongoSwahili = QLocale__Language(250)
|
|
QLocale__Tasawaq = QLocale__Language(251)
|
|
QLocale__Vai = QLocale__Language(252)
|
|
QLocale__Walser = QLocale__Language(253)
|
|
QLocale__Yangben = QLocale__Language(254)
|
|
QLocale__Avestan = QLocale__Language(255)
|
|
QLocale__Asturian = QLocale__Language(256)
|
|
QLocale__Ngomba = QLocale__Language(257)
|
|
QLocale__Kako = QLocale__Language(258)
|
|
QLocale__Meta = QLocale__Language(259)
|
|
QLocale__Ngiemboon = QLocale__Language(260)
|
|
QLocale__Aragonese = QLocale__Language(261)
|
|
QLocale__Akkadian = QLocale__Language(262)
|
|
QLocale__AncientEgyptian = QLocale__Language(263)
|
|
QLocale__AncientGreek = QLocale__Language(264)
|
|
QLocale__Aramaic = QLocale__Language(265)
|
|
QLocale__Balinese = QLocale__Language(266)
|
|
QLocale__Bamun = QLocale__Language(267)
|
|
QLocale__BatakToba = QLocale__Language(268)
|
|
QLocale__Buginese = QLocale__Language(269)
|
|
QLocale__Buhid = QLocale__Language(270)
|
|
QLocale__Carian = QLocale__Language(271)
|
|
QLocale__Chakma = QLocale__Language(272)
|
|
QLocale__ClassicalMandaic = QLocale__Language(273)
|
|
QLocale__Coptic = QLocale__Language(274)
|
|
QLocale__Dogri = QLocale__Language(275)
|
|
QLocale__EasternCham = QLocale__Language(276)
|
|
QLocale__EasternKayah = QLocale__Language(277)
|
|
QLocale__Etruscan = QLocale__Language(278)
|
|
QLocale__Gothic = QLocale__Language(279)
|
|
QLocale__Hanunoo = QLocale__Language(280)
|
|
QLocale__Ingush = QLocale__Language(281)
|
|
QLocale__LargeFloweryMiao = QLocale__Language(282)
|
|
QLocale__Lepcha = QLocale__Language(283)
|
|
QLocale__Limbu = QLocale__Language(284)
|
|
QLocale__Lisu = QLocale__Language(285)
|
|
QLocale__Lu = QLocale__Language(286)
|
|
QLocale__Lycian = QLocale__Language(287)
|
|
QLocale__Lydian = QLocale__Language(288)
|
|
QLocale__Mandingo = QLocale__Language(289)
|
|
QLocale__Manipuri = QLocale__Language(290)
|
|
QLocale__Meroitic = QLocale__Language(291)
|
|
QLocale__NorthernThai = QLocale__Language(292)
|
|
QLocale__OldIrish = QLocale__Language(293)
|
|
QLocale__OldNorse = QLocale__Language(294)
|
|
QLocale__OldPersian = QLocale__Language(295)
|
|
QLocale__OldTurkish = QLocale__Language(296)
|
|
QLocale__Pahlavi = QLocale__Language(297)
|
|
QLocale__Parthian = QLocale__Language(298)
|
|
QLocale__Phoenician = QLocale__Language(299)
|
|
QLocale__PrakritLanguage = QLocale__Language(300)
|
|
QLocale__Rejang = QLocale__Language(301)
|
|
QLocale__Sabaean = QLocale__Language(302)
|
|
QLocale__Samaritan = QLocale__Language(303)
|
|
QLocale__Santali = QLocale__Language(304)
|
|
QLocale__Saurashtra = QLocale__Language(305)
|
|
QLocale__Sora = QLocale__Language(306)
|
|
QLocale__Sylheti = QLocale__Language(307)
|
|
QLocale__Tagbanwa = QLocale__Language(308)
|
|
QLocale__TaiDam = QLocale__Language(309)
|
|
QLocale__TaiNua = QLocale__Language(310)
|
|
QLocale__Ugaritic = QLocale__Language(311)
|
|
QLocale__Akoose = QLocale__Language(312)
|
|
QLocale__Lakota = QLocale__Language(313)
|
|
QLocale__StandardMoroccanTamazight = QLocale__Language(314)
|
|
QLocale__Mapuche = QLocale__Language(315)
|
|
QLocale__CentralKurdish = QLocale__Language(316)
|
|
QLocale__LowerSorbian = QLocale__Language(317)
|
|
QLocale__UpperSorbian = QLocale__Language(318)
|
|
QLocale__Kenyang = QLocale__Language(319)
|
|
QLocale__Mohawk = QLocale__Language(320)
|
|
QLocale__Nko = QLocale__Language(321)
|
|
QLocale__Prussian = QLocale__Language(322)
|
|
QLocale__Kiche = QLocale__Language(323)
|
|
QLocale__SouthernSami = QLocale__Language(324)
|
|
QLocale__LuleSami = QLocale__Language(325)
|
|
QLocale__InariSami = QLocale__Language(326)
|
|
QLocale__SkoltSami = QLocale__Language(327)
|
|
QLocale__Warlpiri = QLocale__Language(328)
|
|
QLocale__ManichaeanMiddlePersian = QLocale__Language(329)
|
|
QLocale__Mende = QLocale__Language(330)
|
|
QLocale__AncientNorthArabian = QLocale__Language(331)
|
|
QLocale__LinearA = QLocale__Language(332)
|
|
QLocale__HmongNjua = QLocale__Language(333)
|
|
QLocale__Ho = QLocale__Language(334)
|
|
QLocale__Lezghian = QLocale__Language(335)
|
|
QLocale__Bassa = QLocale__Language(336)
|
|
QLocale__Mono = QLocale__Language(337)
|
|
QLocale__TedimChin = QLocale__Language(338)
|
|
QLocale__Maithili = QLocale__Language(339)
|
|
QLocale__Norwegian = QLocale__Language(QLocale__NorwegianBokmal)
|
|
QLocale__Moldavian = QLocale__Language(QLocale__Romanian)
|
|
QLocale__SerboCroatian = QLocale__Language(QLocale__Serbian)
|
|
QLocale__Tagalog = QLocale__Language(QLocale__Filipino)
|
|
QLocale__Twi = QLocale__Language(QLocale__Akan)
|
|
QLocale__Afan = QLocale__Language(QLocale__Oromo)
|
|
QLocale__Byelorussian = QLocale__Language(QLocale__Belarusian)
|
|
QLocale__Bhutani = QLocale__Language(QLocale__Dzongkha)
|
|
QLocale__Cambodian = QLocale__Language(QLocale__Khmer)
|
|
QLocale__Kurundi = QLocale__Language(QLocale__Rundi)
|
|
QLocale__RhaetoRomance = QLocale__Language(QLocale__Romansh)
|
|
QLocale__Chewa = QLocale__Language(QLocale__Nyanja)
|
|
QLocale__Frisian = QLocale__Language(QLocale__WesternFrisian)
|
|
QLocale__Uigur = QLocale__Language(QLocale__Uighur)
|
|
QLocale__LastLanguage = QLocale__Language(QLocale__Maithili)
|
|
)
|
|
|
|
//QLocale::MeasurementSystem
|
|
type QLocale__MeasurementSystem int64
|
|
|
|
const (
|
|
QLocale__MetricSystem = QLocale__MeasurementSystem(0)
|
|
QLocale__ImperialUSSystem = QLocale__MeasurementSystem(1)
|
|
QLocale__ImperialUKSystem = QLocale__MeasurementSystem(2)
|
|
QLocale__ImperialSystem = QLocale__MeasurementSystem(QLocale__ImperialUSSystem)
|
|
)
|
|
|
|
//QLocale::NumberOption
|
|
type QLocale__NumberOption int64
|
|
|
|
const (
|
|
QLocale__OmitGroupSeparator = QLocale__NumberOption(0x01)
|
|
QLocale__RejectGroupSeparator = QLocale__NumberOption(0x02)
|
|
)
|
|
|
|
//QLocale::QuotationStyle
|
|
type QLocale__QuotationStyle int64
|
|
|
|
var (
|
|
QLocale__StandardQuotation = QLocale__QuotationStyle(0)
|
|
QLocale__AlternateQuotation = QLocale__QuotationStyle(1)
|
|
)
|
|
|
|
//QLocale::Script
|
|
type QLocale__Script int64
|
|
|
|
const (
|
|
QLocale__AnyScript = QLocale__Script(0)
|
|
QLocale__ArabicScript = QLocale__Script(1)
|
|
QLocale__CyrillicScript = QLocale__Script(2)
|
|
QLocale__DeseretScript = QLocale__Script(3)
|
|
QLocale__GurmukhiScript = QLocale__Script(4)
|
|
QLocale__SimplifiedHanScript = QLocale__Script(5)
|
|
QLocale__TraditionalHanScript = QLocale__Script(6)
|
|
QLocale__LatinScript = QLocale__Script(7)
|
|
QLocale__MongolianScript = QLocale__Script(8)
|
|
QLocale__TifinaghScript = QLocale__Script(9)
|
|
QLocale__ArmenianScript = QLocale__Script(10)
|
|
QLocale__BengaliScript = QLocale__Script(11)
|
|
QLocale__CherokeeScript = QLocale__Script(12)
|
|
QLocale__DevanagariScript = QLocale__Script(13)
|
|
QLocale__EthiopicScript = QLocale__Script(14)
|
|
QLocale__GeorgianScript = QLocale__Script(15)
|
|
QLocale__GreekScript = QLocale__Script(16)
|
|
QLocale__GujaratiScript = QLocale__Script(17)
|
|
QLocale__HebrewScript = QLocale__Script(18)
|
|
QLocale__JapaneseScript = QLocale__Script(19)
|
|
QLocale__KhmerScript = QLocale__Script(20)
|
|
QLocale__KannadaScript = QLocale__Script(21)
|
|
QLocale__KoreanScript = QLocale__Script(22)
|
|
QLocale__LaoScript = QLocale__Script(23)
|
|
QLocale__MalayalamScript = QLocale__Script(24)
|
|
QLocale__MyanmarScript = QLocale__Script(25)
|
|
QLocale__OriyaScript = QLocale__Script(26)
|
|
QLocale__TamilScript = QLocale__Script(27)
|
|
QLocale__TeluguScript = QLocale__Script(28)
|
|
QLocale__ThaanaScript = QLocale__Script(29)
|
|
QLocale__ThaiScript = QLocale__Script(30)
|
|
QLocale__TibetanScript = QLocale__Script(31)
|
|
QLocale__SinhalaScript = QLocale__Script(32)
|
|
QLocale__SyriacScript = QLocale__Script(33)
|
|
QLocale__YiScript = QLocale__Script(34)
|
|
QLocale__VaiScript = QLocale__Script(35)
|
|
QLocale__AvestanScript = QLocale__Script(36)
|
|
QLocale__BalineseScript = QLocale__Script(37)
|
|
QLocale__BamumScript = QLocale__Script(38)
|
|
QLocale__BatakScript = QLocale__Script(39)
|
|
QLocale__BopomofoScript = QLocale__Script(40)
|
|
QLocale__BrahmiScript = QLocale__Script(41)
|
|
QLocale__BugineseScript = QLocale__Script(42)
|
|
QLocale__BuhidScript = QLocale__Script(43)
|
|
QLocale__CanadianAboriginalScript = QLocale__Script(44)
|
|
QLocale__CarianScript = QLocale__Script(45)
|
|
QLocale__ChakmaScript = QLocale__Script(46)
|
|
QLocale__ChamScript = QLocale__Script(47)
|
|
QLocale__CopticScript = QLocale__Script(48)
|
|
QLocale__CypriotScript = QLocale__Script(49)
|
|
QLocale__EgyptianHieroglyphsScript = QLocale__Script(50)
|
|
QLocale__FraserScript = QLocale__Script(51)
|
|
QLocale__GlagoliticScript = QLocale__Script(52)
|
|
QLocale__GothicScript = QLocale__Script(53)
|
|
QLocale__HanScript = QLocale__Script(54)
|
|
QLocale__HangulScript = QLocale__Script(55)
|
|
QLocale__HanunooScript = QLocale__Script(56)
|
|
QLocale__ImperialAramaicScript = QLocale__Script(57)
|
|
QLocale__InscriptionalPahlaviScript = QLocale__Script(58)
|
|
QLocale__InscriptionalParthianScript = QLocale__Script(59)
|
|
QLocale__JavaneseScript = QLocale__Script(60)
|
|
QLocale__KaithiScript = QLocale__Script(61)
|
|
QLocale__KatakanaScript = QLocale__Script(62)
|
|
QLocale__KayahLiScript = QLocale__Script(63)
|
|
QLocale__KharoshthiScript = QLocale__Script(64)
|
|
QLocale__LannaScript = QLocale__Script(65)
|
|
QLocale__LepchaScript = QLocale__Script(66)
|
|
QLocale__LimbuScript = QLocale__Script(67)
|
|
QLocale__LinearBScript = QLocale__Script(68)
|
|
QLocale__LycianScript = QLocale__Script(69)
|
|
QLocale__LydianScript = QLocale__Script(70)
|
|
QLocale__MandaeanScript = QLocale__Script(71)
|
|
QLocale__MeiteiMayekScript = QLocale__Script(72)
|
|
QLocale__MeroiticScript = QLocale__Script(73)
|
|
QLocale__MeroiticCursiveScript = QLocale__Script(74)
|
|
QLocale__NkoScript = QLocale__Script(75)
|
|
QLocale__NewTaiLueScript = QLocale__Script(76)
|
|
QLocale__OghamScript = QLocale__Script(77)
|
|
QLocale__OlChikiScript = QLocale__Script(78)
|
|
QLocale__OldItalicScript = QLocale__Script(79)
|
|
QLocale__OldPersianScript = QLocale__Script(80)
|
|
QLocale__OldSouthArabianScript = QLocale__Script(81)
|
|
QLocale__OrkhonScript = QLocale__Script(82)
|
|
QLocale__OsmanyaScript = QLocale__Script(83)
|
|
QLocale__PhagsPaScript = QLocale__Script(84)
|
|
QLocale__PhoenicianScript = QLocale__Script(85)
|
|
QLocale__PollardPhoneticScript = QLocale__Script(86)
|
|
QLocale__RejangScript = QLocale__Script(87)
|
|
QLocale__RunicScript = QLocale__Script(88)
|
|
QLocale__SamaritanScript = QLocale__Script(89)
|
|
QLocale__SaurashtraScript = QLocale__Script(90)
|
|
QLocale__SharadaScript = QLocale__Script(91)
|
|
QLocale__ShavianScript = QLocale__Script(92)
|
|
QLocale__SoraSompengScript = QLocale__Script(93)
|
|
QLocale__CuneiformScript = QLocale__Script(94)
|
|
QLocale__SundaneseScript = QLocale__Script(95)
|
|
QLocale__SylotiNagriScript = QLocale__Script(96)
|
|
QLocale__TagalogScript = QLocale__Script(97)
|
|
QLocale__TagbanwaScript = QLocale__Script(98)
|
|
QLocale__TaiLeScript = QLocale__Script(99)
|
|
QLocale__TaiVietScript = QLocale__Script(100)
|
|
QLocale__TakriScript = QLocale__Script(101)
|
|
QLocale__UgariticScript = QLocale__Script(102)
|
|
QLocale__BrailleScript = QLocale__Script(103)
|
|
QLocale__HiraganaScript = QLocale__Script(104)
|
|
QLocale__CaucasianAlbanianScript = QLocale__Script(105)
|
|
QLocale__BassaVahScript = QLocale__Script(106)
|
|
QLocale__DuployanScript = QLocale__Script(107)
|
|
QLocale__ElbasanScript = QLocale__Script(108)
|
|
QLocale__GranthaScript = QLocale__Script(109)
|
|
QLocale__PahawhHmongScript = QLocale__Script(110)
|
|
QLocale__KhojkiScript = QLocale__Script(111)
|
|
QLocale__LinearAScript = QLocale__Script(112)
|
|
QLocale__MahajaniScript = QLocale__Script(113)
|
|
QLocale__ManichaeanScript = QLocale__Script(114)
|
|
QLocale__MendeKikakuiScript = QLocale__Script(115)
|
|
QLocale__ModiScript = QLocale__Script(116)
|
|
QLocale__MroScript = QLocale__Script(117)
|
|
QLocale__OldNorthArabianScript = QLocale__Script(118)
|
|
QLocale__NabataeanScript = QLocale__Script(119)
|
|
QLocale__PalmyreneScript = QLocale__Script(120)
|
|
QLocale__PauCinHauScript = QLocale__Script(121)
|
|
QLocale__OldPermicScript = QLocale__Script(122)
|
|
QLocale__PsalterPahlaviScript = QLocale__Script(123)
|
|
QLocale__SiddhamScript = QLocale__Script(124)
|
|
QLocale__KhudawadiScript = QLocale__Script(125)
|
|
QLocale__TirhutaScript = QLocale__Script(126)
|
|
QLocale__VarangKshitiScript = QLocale__Script(127)
|
|
QLocale__SimplifiedChineseScript = QLocale__Script(QLocale__SimplifiedHanScript)
|
|
QLocale__TraditionalChineseScript = QLocale__Script(QLocale__TraditionalHanScript)
|
|
QLocale__LastScript = QLocale__Script(QLocale__VarangKshitiScript)
|
|
)
|
|
|
|
type QLocale struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QLocale_ITF interface {
|
|
QLocale_PTR() *QLocale
|
|
}
|
|
|
|
func (p *QLocale) QLocale_PTR() *QLocale {
|
|
return p
|
|
}
|
|
|
|
func (p *QLocale) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QLocale) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQLocale(ptr QLocale_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QLocale_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQLocaleFromPointer(ptr unsafe.Pointer) *QLocale {
|
|
var n = new(QLocale)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQLocaleFromPointer(ptr unsafe.Pointer) *QLocale {
|
|
var n = NewQLocaleFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQLocale() *QLocale {
|
|
defer qt.Recovering("QLocale::QLocale")
|
|
|
|
return newQLocaleFromPointer(C.QLocale_NewQLocale())
|
|
}
|
|
|
|
func NewQLocale3(language QLocale__Language, country QLocale__Country) *QLocale {
|
|
defer qt.Recovering("QLocale::QLocale")
|
|
|
|
return newQLocaleFromPointer(C.QLocale_NewQLocale3(C.int(language), C.int(country)))
|
|
}
|
|
|
|
func NewQLocale4(language QLocale__Language, script QLocale__Script, country QLocale__Country) *QLocale {
|
|
defer qt.Recovering("QLocale::QLocale")
|
|
|
|
return newQLocaleFromPointer(C.QLocale_NewQLocale4(C.int(language), C.int(script), C.int(country)))
|
|
}
|
|
|
|
func NewQLocale5(other QLocale_ITF) *QLocale {
|
|
defer qt.Recovering("QLocale::QLocale")
|
|
|
|
return newQLocaleFromPointer(C.QLocale_NewQLocale5(PointerFromQLocale(other)))
|
|
}
|
|
|
|
func NewQLocale2(name string) *QLocale {
|
|
defer qt.Recovering("QLocale::QLocale")
|
|
|
|
return newQLocaleFromPointer(C.QLocale_NewQLocale2(C.CString(name)))
|
|
}
|
|
|
|
func (ptr *QLocale) AmText() string {
|
|
defer qt.Recovering("QLocale::amText")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_AmText(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) Bcp47Name() string {
|
|
defer qt.Recovering("QLocale::bcp47Name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_Bcp47Name(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func QLocale_C() *QLocale {
|
|
defer qt.Recovering("QLocale::c")
|
|
|
|
return NewQLocaleFromPointer(C.QLocale_QLocale_C())
|
|
}
|
|
|
|
func (ptr *QLocale) C() *QLocale {
|
|
defer qt.Recovering("QLocale::c")
|
|
|
|
return NewQLocaleFromPointer(C.QLocale_QLocale_C())
|
|
}
|
|
|
|
func (ptr *QLocale) Country() QLocale__Country {
|
|
defer qt.Recovering("QLocale::country")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QLocale__Country(C.QLocale_Country(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QLocale_CountryToString(country QLocale__Country) string {
|
|
defer qt.Recovering("QLocale::countryToString")
|
|
|
|
return C.GoString(C.QLocale_QLocale_CountryToString(C.int(country)))
|
|
}
|
|
|
|
func (ptr *QLocale) CountryToString(country QLocale__Country) string {
|
|
defer qt.Recovering("QLocale::countryToString")
|
|
|
|
return C.GoString(C.QLocale_QLocale_CountryToString(C.int(country)))
|
|
}
|
|
|
|
func (ptr *QLocale) CreateSeparatedList(list []string) string {
|
|
defer qt.Recovering("QLocale::createSeparatedList")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_CreateSeparatedList(ptr.Pointer(), C.CString(strings.Join(list, "|"))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) CurrencySymbol(format QLocale__CurrencySymbolFormat) string {
|
|
defer qt.Recovering("QLocale::currencySymbol")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_CurrencySymbol(ptr.Pointer(), C.int(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) DateFormat(format QLocale__FormatType) string {
|
|
defer qt.Recovering("QLocale::dateFormat")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_DateFormat(ptr.Pointer(), C.int(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) DateTimeFormat(format QLocale__FormatType) string {
|
|
defer qt.Recovering("QLocale::dateTimeFormat")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_DateTimeFormat(ptr.Pointer(), C.int(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) DayName(day int, ty QLocale__FormatType) string {
|
|
defer qt.Recovering("QLocale::dayName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_DayName(ptr.Pointer(), C.int(day), C.int(ty)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) FirstDayOfWeek() Qt__DayOfWeek {
|
|
defer qt.Recovering("QLocale::firstDayOfWeek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DayOfWeek(C.QLocale_FirstDayOfWeek(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLocale) Language() QLocale__Language {
|
|
defer qt.Recovering("QLocale::language")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QLocale__Language(C.QLocale_Language(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QLocale_LanguageToString(language QLocale__Language) string {
|
|
defer qt.Recovering("QLocale::languageToString")
|
|
|
|
return C.GoString(C.QLocale_QLocale_LanguageToString(C.int(language)))
|
|
}
|
|
|
|
func (ptr *QLocale) LanguageToString(language QLocale__Language) string {
|
|
defer qt.Recovering("QLocale::languageToString")
|
|
|
|
return C.GoString(C.QLocale_QLocale_LanguageToString(C.int(language)))
|
|
}
|
|
|
|
func (ptr *QLocale) MeasurementSystem() QLocale__MeasurementSystem {
|
|
defer qt.Recovering("QLocale::measurementSystem")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QLocale__MeasurementSystem(C.QLocale_MeasurementSystem(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLocale) MonthName(month int, ty QLocale__FormatType) string {
|
|
defer qt.Recovering("QLocale::monthName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_MonthName(ptr.Pointer(), C.int(month), C.int(ty)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) Name() string {
|
|
defer qt.Recovering("QLocale::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_Name(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) NativeCountryName() string {
|
|
defer qt.Recovering("QLocale::nativeCountryName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_NativeCountryName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) NativeLanguageName() string {
|
|
defer qt.Recovering("QLocale::nativeLanguageName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_NativeLanguageName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) NumberOptions() QLocale__NumberOption {
|
|
defer qt.Recovering("QLocale::numberOptions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QLocale__NumberOption(C.QLocale_NumberOptions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLocale) PmText() string {
|
|
defer qt.Recovering("QLocale::pmText")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_PmText(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) QuoteString(str string, style QLocale__QuotationStyle) string {
|
|
defer qt.Recovering("QLocale::quoteString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_QuoteString(ptr.Pointer(), C.CString(str), C.int(style)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) QuoteString2(str QStringRef_ITF, style QLocale__QuotationStyle) string {
|
|
defer qt.Recovering("QLocale::quoteString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_QuoteString2(ptr.Pointer(), PointerFromQStringRef(str), C.int(style)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) Script() QLocale__Script {
|
|
defer qt.Recovering("QLocale::script")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QLocale__Script(C.QLocale_Script(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QLocale_ScriptToString(script QLocale__Script) string {
|
|
defer qt.Recovering("QLocale::scriptToString")
|
|
|
|
return C.GoString(C.QLocale_QLocale_ScriptToString(C.int(script)))
|
|
}
|
|
|
|
func (ptr *QLocale) ScriptToString(script QLocale__Script) string {
|
|
defer qt.Recovering("QLocale::scriptToString")
|
|
|
|
return C.GoString(C.QLocale_QLocale_ScriptToString(C.int(script)))
|
|
}
|
|
|
|
func QLocale_SetDefault(locale QLocale_ITF) {
|
|
defer qt.Recovering("QLocale::setDefault")
|
|
|
|
C.QLocale_QLocale_SetDefault(PointerFromQLocale(locale))
|
|
}
|
|
|
|
func (ptr *QLocale) SetDefault(locale QLocale_ITF) {
|
|
defer qt.Recovering("QLocale::setDefault")
|
|
|
|
C.QLocale_QLocale_SetDefault(PointerFromQLocale(locale))
|
|
}
|
|
|
|
func (ptr *QLocale) SetNumberOptions(options QLocale__NumberOption) {
|
|
defer qt.Recovering("QLocale::setNumberOptions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLocale_SetNumberOptions(ptr.Pointer(), C.int(options))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLocale) StandaloneDayName(day int, ty QLocale__FormatType) string {
|
|
defer qt.Recovering("QLocale::standaloneDayName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_StandaloneDayName(ptr.Pointer(), C.int(day), C.int(ty)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) StandaloneMonthName(month int, ty QLocale__FormatType) string {
|
|
defer qt.Recovering("QLocale::standaloneMonthName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_StandaloneMonthName(ptr.Pointer(), C.int(month), C.int(ty)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func QLocale_System() *QLocale {
|
|
defer qt.Recovering("QLocale::system")
|
|
|
|
return NewQLocaleFromPointer(C.QLocale_QLocale_System())
|
|
}
|
|
|
|
func (ptr *QLocale) System() *QLocale {
|
|
defer qt.Recovering("QLocale::system")
|
|
|
|
return NewQLocaleFromPointer(C.QLocale_QLocale_System())
|
|
}
|
|
|
|
func (ptr *QLocale) TextDirection() Qt__LayoutDirection {
|
|
defer qt.Recovering("QLocale::textDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__LayoutDirection(C.QLocale_TextDirection(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLocale) TimeFormat(format QLocale__FormatType) string {
|
|
defer qt.Recovering("QLocale::timeFormat")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_TimeFormat(ptr.Pointer(), C.int(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) ToCurrencyString5(value int, symbol string) string {
|
|
defer qt.Recovering("QLocale::toCurrencyString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_ToCurrencyString5(ptr.Pointer(), C.int(value), C.CString(symbol)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) ToDateTime(stri string, format QLocale__FormatType) *QDateTime {
|
|
defer qt.Recovering("QLocale::toDateTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QLocale_ToDateTime(ptr.Pointer(), C.CString(stri), C.int(format)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLocale) ToDateTime2(stri string, format string) *QDateTime {
|
|
defer qt.Recovering("QLocale::toDateTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QLocale_ToDateTime2(ptr.Pointer(), C.CString(stri), C.CString(format)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QLocale) ToInt(s string, ok bool) int {
|
|
defer qt.Recovering("QLocale::toInt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QLocale_ToInt(ptr.Pointer(), C.CString(s), C.int(qt.GoBoolToInt(ok))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLocale) ToInt2(s QStringRef_ITF, ok bool) int {
|
|
defer qt.Recovering("QLocale::toInt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QLocale_ToInt2(ptr.Pointer(), PointerFromQStringRef(s), C.int(qt.GoBoolToInt(ok))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLocale) ToLower(str string) string {
|
|
defer qt.Recovering("QLocale::toLower")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_ToLower(ptr.Pointer(), C.CString(str)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) ToString10(date QDate_ITF, format QLocale__FormatType) string {
|
|
defer qt.Recovering("QLocale::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_ToString10(ptr.Pointer(), PointerFromQDate(date), C.int(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) ToString9(date QDate_ITF, format string) string {
|
|
defer qt.Recovering("QLocale::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_ToString9(ptr.Pointer(), PointerFromQDate(date), C.CString(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) ToString13(dateTime QDateTime_ITF, format QLocale__FormatType) string {
|
|
defer qt.Recovering("QLocale::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_ToString13(ptr.Pointer(), PointerFromQDateTime(dateTime), C.int(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) ToString14(dateTime QDateTime_ITF, format string) string {
|
|
defer qt.Recovering("QLocale::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_ToString14(ptr.Pointer(), PointerFromQDateTime(dateTime), C.CString(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) ToString12(time QTime_ITF, format QLocale__FormatType) string {
|
|
defer qt.Recovering("QLocale::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_ToString12(ptr.Pointer(), PointerFromQTime(time), C.int(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) ToString11(time QTime_ITF, format string) string {
|
|
defer qt.Recovering("QLocale::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_ToString11(ptr.Pointer(), PointerFromQTime(time), C.CString(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) ToString5(i int) string {
|
|
defer qt.Recovering("QLocale::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_ToString5(ptr.Pointer(), C.int(i)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) ToUpper(str string) string {
|
|
defer qt.Recovering("QLocale::toUpper")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLocale_ToUpper(ptr.Pointer(), C.CString(str)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QLocale) UiLanguages() []string {
|
|
defer qt.Recovering("QLocale::uiLanguages")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QLocale_UiLanguages(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QLocale) DestroyQLocale() {
|
|
defer qt.Recovering("QLocale::~QLocale")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLocale_DestroyQLocale(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QLockFile::LockError
|
|
type QLockFile__LockError int64
|
|
|
|
const (
|
|
QLockFile__NoError = QLockFile__LockError(0)
|
|
QLockFile__LockFailedError = QLockFile__LockError(1)
|
|
QLockFile__PermissionError = QLockFile__LockError(2)
|
|
QLockFile__UnknownError = QLockFile__LockError(3)
|
|
)
|
|
|
|
type QLockFile struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QLockFile_ITF interface {
|
|
QLockFile_PTR() *QLockFile
|
|
}
|
|
|
|
func (p *QLockFile) QLockFile_PTR() *QLockFile {
|
|
return p
|
|
}
|
|
|
|
func (p *QLockFile) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QLockFile) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQLockFile(ptr QLockFile_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QLockFile_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQLockFileFromPointer(ptr unsafe.Pointer) *QLockFile {
|
|
var n = new(QLockFile)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQLockFileFromPointer(ptr unsafe.Pointer) *QLockFile {
|
|
var n = NewQLockFileFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQLockFile(fileName string) *QLockFile {
|
|
defer qt.Recovering("QLockFile::QLockFile")
|
|
|
|
return newQLockFileFromPointer(C.QLockFile_NewQLockFile(C.CString(fileName)))
|
|
}
|
|
|
|
func (ptr *QLockFile) Error() QLockFile__LockError {
|
|
defer qt.Recovering("QLockFile::error")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QLockFile__LockError(C.QLockFile_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLockFile) IsLocked() bool {
|
|
defer qt.Recovering("QLockFile::isLocked")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLockFile_IsLocked(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLockFile) Lock() bool {
|
|
defer qt.Recovering("QLockFile::lock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLockFile_Lock(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLockFile) RemoveStaleLockFile() bool {
|
|
defer qt.Recovering("QLockFile::removeStaleLockFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLockFile_RemoveStaleLockFile(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLockFile) SetStaleLockTime(staleLockTime int) {
|
|
defer qt.Recovering("QLockFile::setStaleLockTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLockFile_SetStaleLockTime(ptr.Pointer(), C.int(staleLockTime))
|
|
}
|
|
}
|
|
|
|
func (ptr *QLockFile) StaleLockTime() int {
|
|
defer qt.Recovering("QLockFile::staleLockTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QLockFile_StaleLockTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QLockFile) TryLock(timeout int) bool {
|
|
defer qt.Recovering("QLockFile::tryLock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLockFile_TryLock(ptr.Pointer(), C.int(timeout)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLockFile) DestroyQLockFile() {
|
|
defer qt.Recovering("QLockFile::~QLockFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLockFile_DestroyQLockFile(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QLockFile) Unlock() {
|
|
defer qt.Recovering("QLockFile::unlock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLockFile_Unlock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
type QLoggingCategory struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QLoggingCategory_ITF interface {
|
|
QLoggingCategory_PTR() *QLoggingCategory
|
|
}
|
|
|
|
func (p *QLoggingCategory) QLoggingCategory_PTR() *QLoggingCategory {
|
|
return p
|
|
}
|
|
|
|
func (p *QLoggingCategory) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QLoggingCategory) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQLoggingCategory(ptr QLoggingCategory_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QLoggingCategory_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQLoggingCategoryFromPointer(ptr unsafe.Pointer) *QLoggingCategory {
|
|
var n = new(QLoggingCategory)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQLoggingCategoryFromPointer(ptr unsafe.Pointer) *QLoggingCategory {
|
|
var n = NewQLoggingCategoryFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQLoggingCategory(category string) *QLoggingCategory {
|
|
defer qt.Recovering("QLoggingCategory::QLoggingCategory")
|
|
|
|
return newQLoggingCategoryFromPointer(C.QLoggingCategory_NewQLoggingCategory(C.CString(category)))
|
|
}
|
|
|
|
func (ptr *QLoggingCategory) CategoryName() string {
|
|
defer qt.Recovering("QLoggingCategory::categoryName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QLoggingCategory_CategoryName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func QLoggingCategory_DefaultCategory() *QLoggingCategory {
|
|
defer qt.Recovering("QLoggingCategory::defaultCategory")
|
|
|
|
return NewQLoggingCategoryFromPointer(C.QLoggingCategory_QLoggingCategory_DefaultCategory())
|
|
}
|
|
|
|
func (ptr *QLoggingCategory) DefaultCategory() *QLoggingCategory {
|
|
defer qt.Recovering("QLoggingCategory::defaultCategory")
|
|
|
|
return NewQLoggingCategoryFromPointer(C.QLoggingCategory_QLoggingCategory_DefaultCategory())
|
|
}
|
|
|
|
func (ptr *QLoggingCategory) IsCriticalEnabled() bool {
|
|
defer qt.Recovering("QLoggingCategory::isCriticalEnabled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLoggingCategory_IsCriticalEnabled(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLoggingCategory) IsDebugEnabled() bool {
|
|
defer qt.Recovering("QLoggingCategory::isDebugEnabled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLoggingCategory_IsDebugEnabled(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLoggingCategory) IsInfoEnabled() bool {
|
|
defer qt.Recovering("QLoggingCategory::isInfoEnabled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLoggingCategory_IsInfoEnabled(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QLoggingCategory) IsWarningEnabled() bool {
|
|
defer qt.Recovering("QLoggingCategory::isWarningEnabled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QLoggingCategory_IsWarningEnabled(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QLoggingCategory_SetFilterRules(rules string) {
|
|
defer qt.Recovering("QLoggingCategory::setFilterRules")
|
|
|
|
C.QLoggingCategory_QLoggingCategory_SetFilterRules(C.CString(rules))
|
|
}
|
|
|
|
func (ptr *QLoggingCategory) SetFilterRules(rules string) {
|
|
defer qt.Recovering("QLoggingCategory::setFilterRules")
|
|
|
|
C.QLoggingCategory_QLoggingCategory_SetFilterRules(C.CString(rules))
|
|
}
|
|
|
|
func (ptr *QLoggingCategory) DestroyQLoggingCategory() {
|
|
defer qt.Recovering("QLoggingCategory::~QLoggingCategory")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QLoggingCategory_DestroyQLoggingCategory(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QMap struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMap_ITF interface {
|
|
QMap_PTR() *QMap
|
|
}
|
|
|
|
func (p *QMap) QMap_PTR() *QMap {
|
|
return p
|
|
}
|
|
|
|
func (p *QMap) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMap) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMap(ptr QMap_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMap_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMapFromPointer(ptr unsafe.Pointer) *QMap {
|
|
var n = new(QMap)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMapFromPointer(ptr unsafe.Pointer) *QMap {
|
|
var n = NewQMapFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QMapIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMapIterator_ITF interface {
|
|
QMapIterator_PTR() *QMapIterator
|
|
}
|
|
|
|
func (p *QMapIterator) QMapIterator_PTR() *QMapIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QMapIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMapIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMapIterator(ptr QMapIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMapIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMapIteratorFromPointer(ptr unsafe.Pointer) *QMapIterator {
|
|
var n = new(QMapIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMapIteratorFromPointer(ptr unsafe.Pointer) *QMapIterator {
|
|
var n = NewQMapIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QMargins struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMargins_ITF interface {
|
|
QMargins_PTR() *QMargins
|
|
}
|
|
|
|
func (p *QMargins) QMargins_PTR() *QMargins {
|
|
return p
|
|
}
|
|
|
|
func (p *QMargins) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMargins) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMargins(ptr QMargins_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMargins_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMarginsFromPointer(ptr unsafe.Pointer) *QMargins {
|
|
var n = new(QMargins)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMarginsFromPointer(ptr unsafe.Pointer) *QMargins {
|
|
var n = NewQMarginsFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQMargins() *QMargins {
|
|
defer qt.Recovering("QMargins::QMargins")
|
|
|
|
return newQMarginsFromPointer(C.QMargins_NewQMargins())
|
|
}
|
|
|
|
func NewQMargins2(left int, top int, right int, bottom int) *QMargins {
|
|
defer qt.Recovering("QMargins::QMargins")
|
|
|
|
return newQMarginsFromPointer(C.QMargins_NewQMargins2(C.int(left), C.int(top), C.int(right), C.int(bottom)))
|
|
}
|
|
|
|
func (ptr *QMargins) Bottom() int {
|
|
defer qt.Recovering("QMargins::bottom")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMargins_Bottom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMargins) IsNull() bool {
|
|
defer qt.Recovering("QMargins::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMargins_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMargins) Left() int {
|
|
defer qt.Recovering("QMargins::left")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMargins_Left(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMargins) Right() int {
|
|
defer qt.Recovering("QMargins::right")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMargins_Right(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMargins) SetBottom(bottom int) {
|
|
defer qt.Recovering("QMargins::setBottom")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMargins_SetBottom(ptr.Pointer(), C.int(bottom))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMargins) SetLeft(left int) {
|
|
defer qt.Recovering("QMargins::setLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMargins_SetLeft(ptr.Pointer(), C.int(left))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMargins) SetRight(right int) {
|
|
defer qt.Recovering("QMargins::setRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMargins_SetRight(ptr.Pointer(), C.int(right))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMargins) SetTop(Top int) {
|
|
defer qt.Recovering("QMargins::setTop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMargins_SetTop(ptr.Pointer(), C.int(Top))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMargins) Top() int {
|
|
defer qt.Recovering("QMargins::top")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMargins_Top(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QMarginsF struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMarginsF_ITF interface {
|
|
QMarginsF_PTR() *QMarginsF
|
|
}
|
|
|
|
func (p *QMarginsF) QMarginsF_PTR() *QMarginsF {
|
|
return p
|
|
}
|
|
|
|
func (p *QMarginsF) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMarginsF) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMarginsF(ptr QMarginsF_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMarginsF_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMarginsFFromPointer(ptr unsafe.Pointer) *QMarginsF {
|
|
var n = new(QMarginsF)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMarginsFFromPointer(ptr unsafe.Pointer) *QMarginsF {
|
|
var n = NewQMarginsFFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQMarginsF() *QMarginsF {
|
|
defer qt.Recovering("QMarginsF::QMarginsF")
|
|
|
|
return newQMarginsFFromPointer(C.QMarginsF_NewQMarginsF())
|
|
}
|
|
|
|
func NewQMarginsF3(margins QMargins_ITF) *QMarginsF {
|
|
defer qt.Recovering("QMarginsF::QMarginsF")
|
|
|
|
return newQMarginsFFromPointer(C.QMarginsF_NewQMarginsF3(PointerFromQMargins(margins)))
|
|
}
|
|
|
|
func NewQMarginsF2(left float64, top float64, right float64, bottom float64) *QMarginsF {
|
|
defer qt.Recovering("QMarginsF::QMarginsF")
|
|
|
|
return newQMarginsFFromPointer(C.QMarginsF_NewQMarginsF2(C.double(left), C.double(top), C.double(right), C.double(bottom)))
|
|
}
|
|
|
|
func (ptr *QMarginsF) Bottom() float64 {
|
|
defer qt.Recovering("QMarginsF::bottom")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMarginsF_Bottom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMarginsF) IsNull() bool {
|
|
defer qt.Recovering("QMarginsF::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMarginsF_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMarginsF) Left() float64 {
|
|
defer qt.Recovering("QMarginsF::left")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMarginsF_Left(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMarginsF) Right() float64 {
|
|
defer qt.Recovering("QMarginsF::right")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMarginsF_Right(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMarginsF) SetBottom(bottom float64) {
|
|
defer qt.Recovering("QMarginsF::setBottom")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMarginsF_SetBottom(ptr.Pointer(), C.double(bottom))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMarginsF) SetLeft(left float64) {
|
|
defer qt.Recovering("QMarginsF::setLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMarginsF_SetLeft(ptr.Pointer(), C.double(left))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMarginsF) SetRight(right float64) {
|
|
defer qt.Recovering("QMarginsF::setRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMarginsF_SetRight(ptr.Pointer(), C.double(right))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMarginsF) SetTop(Top float64) {
|
|
defer qt.Recovering("QMarginsF::setTop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMarginsF_SetTop(ptr.Pointer(), C.double(Top))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMarginsF) ToMargins() *QMargins {
|
|
defer qt.Recovering("QMarginsF::toMargins")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMarginsFromPointer(C.QMarginsF_ToMargins(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMarginsF) Top() float64 {
|
|
defer qt.Recovering("QMarginsF::top")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMarginsF_Top(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QMessageAuthenticationCode struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMessageAuthenticationCode_ITF interface {
|
|
QMessageAuthenticationCode_PTR() *QMessageAuthenticationCode
|
|
}
|
|
|
|
func (p *QMessageAuthenticationCode) QMessageAuthenticationCode_PTR() *QMessageAuthenticationCode {
|
|
return p
|
|
}
|
|
|
|
func (p *QMessageAuthenticationCode) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMessageAuthenticationCode) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMessageAuthenticationCode(ptr QMessageAuthenticationCode_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMessageAuthenticationCode_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMessageAuthenticationCodeFromPointer(ptr unsafe.Pointer) *QMessageAuthenticationCode {
|
|
var n = new(QMessageAuthenticationCode)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMessageAuthenticationCodeFromPointer(ptr unsafe.Pointer) *QMessageAuthenticationCode {
|
|
var n = NewQMessageAuthenticationCodeFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQMessageAuthenticationCode(method QCryptographicHash__Algorithm, key string) *QMessageAuthenticationCode {
|
|
defer qt.Recovering("QMessageAuthenticationCode::QMessageAuthenticationCode")
|
|
|
|
return newQMessageAuthenticationCodeFromPointer(C.QMessageAuthenticationCode_NewQMessageAuthenticationCode(C.int(method), C.CString(key)))
|
|
}
|
|
|
|
func (ptr *QMessageAuthenticationCode) AddData3(device QIODevice_ITF) bool {
|
|
defer qt.Recovering("QMessageAuthenticationCode::addData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMessageAuthenticationCode_AddData3(ptr.Pointer(), PointerFromQIODevice(device)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMessageAuthenticationCode) AddData2(data string) {
|
|
defer qt.Recovering("QMessageAuthenticationCode::addData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMessageAuthenticationCode_AddData2(ptr.Pointer(), C.CString(data))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMessageAuthenticationCode) AddData(data string, length int) {
|
|
defer qt.Recovering("QMessageAuthenticationCode::addData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMessageAuthenticationCode_AddData(ptr.Pointer(), C.CString(data), C.int(length))
|
|
}
|
|
}
|
|
|
|
func QMessageAuthenticationCode_Hash(message string, key string, method QCryptographicHash__Algorithm) string {
|
|
defer qt.Recovering("QMessageAuthenticationCode::hash")
|
|
|
|
return C.GoString(C.QMessageAuthenticationCode_QMessageAuthenticationCode_Hash(C.CString(message), C.CString(key), C.int(method)))
|
|
}
|
|
|
|
func (ptr *QMessageAuthenticationCode) Hash(message string, key string, method QCryptographicHash__Algorithm) string {
|
|
defer qt.Recovering("QMessageAuthenticationCode::hash")
|
|
|
|
return C.GoString(C.QMessageAuthenticationCode_QMessageAuthenticationCode_Hash(C.CString(message), C.CString(key), C.int(method)))
|
|
}
|
|
|
|
func (ptr *QMessageAuthenticationCode) Reset() {
|
|
defer qt.Recovering("QMessageAuthenticationCode::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMessageAuthenticationCode_Reset(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMessageAuthenticationCode) Result() string {
|
|
defer qt.Recovering("QMessageAuthenticationCode::result")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMessageAuthenticationCode_Result(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMessageAuthenticationCode) SetKey(key string) {
|
|
defer qt.Recovering("QMessageAuthenticationCode::setKey")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMessageAuthenticationCode_SetKey(ptr.Pointer(), C.CString(key))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMessageAuthenticationCode) DestroyQMessageAuthenticationCode() {
|
|
defer qt.Recovering("QMessageAuthenticationCode::~QMessageAuthenticationCode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMessageAuthenticationCode_DestroyQMessageAuthenticationCode(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QMessageLogContext struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMessageLogContext_ITF interface {
|
|
QMessageLogContext_PTR() *QMessageLogContext
|
|
}
|
|
|
|
func (p *QMessageLogContext) QMessageLogContext_PTR() *QMessageLogContext {
|
|
return p
|
|
}
|
|
|
|
func (p *QMessageLogContext) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMessageLogContext) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMessageLogContext(ptr QMessageLogContext_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMessageLogContext_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMessageLogContextFromPointer(ptr unsafe.Pointer) *QMessageLogContext {
|
|
var n = new(QMessageLogContext)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMessageLogContextFromPointer(ptr unsafe.Pointer) *QMessageLogContext {
|
|
var n = NewQMessageLogContextFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QMessageLogContext) Category() string {
|
|
defer qt.Recovering("QMessageLogContext::category")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMessageLogContext_Category(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMessageLogContext) File() string {
|
|
defer qt.Recovering("QMessageLogContext::file")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMessageLogContext_File(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMessageLogContext) Function() string {
|
|
defer qt.Recovering("QMessageLogContext::function")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMessageLogContext_Function(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMessageLogContext) Line() int {
|
|
defer qt.Recovering("QMessageLogContext::line")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMessageLogContext_Line(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMessageLogContext) SetLine(vin int) {
|
|
defer qt.Recovering("QMessageLogContext::setLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMessageLogContext_SetLine(ptr.Pointer(), C.int(vin))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMessageLogContext) Version() int {
|
|
defer qt.Recovering("QMessageLogContext::version")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMessageLogContext_Version(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMessageLogContext) SetVersion(vin int) {
|
|
defer qt.Recovering("QMessageLogContext::setVersion")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMessageLogContext_SetVersion(ptr.Pointer(), C.int(vin))
|
|
}
|
|
}
|
|
|
|
type QMessageLogger struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMessageLogger_ITF interface {
|
|
QMessageLogger_PTR() *QMessageLogger
|
|
}
|
|
|
|
func (p *QMessageLogger) QMessageLogger_PTR() *QMessageLogger {
|
|
return p
|
|
}
|
|
|
|
func (p *QMessageLogger) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMessageLogger) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMessageLogger(ptr QMessageLogger_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMessageLogger_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMessageLoggerFromPointer(ptr unsafe.Pointer) *QMessageLogger {
|
|
var n = new(QMessageLogger)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMessageLoggerFromPointer(ptr unsafe.Pointer) *QMessageLogger {
|
|
var n = NewQMessageLoggerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQMessageLogger() *QMessageLogger {
|
|
defer qt.Recovering("QMessageLogger::QMessageLogger")
|
|
|
|
return newQMessageLoggerFromPointer(C.QMessageLogger_NewQMessageLogger())
|
|
}
|
|
|
|
func NewQMessageLogger2(file string, line int, function string) *QMessageLogger {
|
|
defer qt.Recovering("QMessageLogger::QMessageLogger")
|
|
|
|
return newQMessageLoggerFromPointer(C.QMessageLogger_NewQMessageLogger2(C.CString(file), C.int(line), C.CString(function)))
|
|
}
|
|
|
|
func NewQMessageLogger3(file string, line int, function string, category string) *QMessageLogger {
|
|
defer qt.Recovering("QMessageLogger::QMessageLogger")
|
|
|
|
return newQMessageLoggerFromPointer(C.QMessageLogger_NewQMessageLogger3(C.CString(file), C.int(line), C.CString(function), C.CString(category)))
|
|
}
|
|
|
|
func (ptr *QMessageLogger) Critical4() *QDebug {
|
|
defer qt.Recovering("QMessageLogger::critical")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QMessageLogger_Critical4(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMessageLogger) Critical5(cat QLoggingCategory_ITF) *QDebug {
|
|
defer qt.Recovering("QMessageLogger::critical")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QMessageLogger_Critical5(ptr.Pointer(), PointerFromQLoggingCategory(cat)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMessageLogger) Debug4() *QDebug {
|
|
defer qt.Recovering("QMessageLogger::debug")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QMessageLogger_Debug4(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMessageLogger) Debug5(cat QLoggingCategory_ITF) *QDebug {
|
|
defer qt.Recovering("QMessageLogger::debug")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QMessageLogger_Debug5(ptr.Pointer(), PointerFromQLoggingCategory(cat)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMessageLogger) Info4() *QDebug {
|
|
defer qt.Recovering("QMessageLogger::info")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QMessageLogger_Info4(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMessageLogger) Info5(cat QLoggingCategory_ITF) *QDebug {
|
|
defer qt.Recovering("QMessageLogger::info")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QMessageLogger_Info5(ptr.Pointer(), PointerFromQLoggingCategory(cat)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMessageLogger) Warning4() *QDebug {
|
|
defer qt.Recovering("QMessageLogger::warning")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QMessageLogger_Warning4(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMessageLogger) Warning5(cat QLoggingCategory_ITF) *QDebug {
|
|
defer qt.Recovering("QMessageLogger::warning")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDebugFromPointer(C.QMessageLogger_Warning5(ptr.Pointer(), PointerFromQLoggingCategory(cat)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QMetaClassInfo struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMetaClassInfo_ITF interface {
|
|
QMetaClassInfo_PTR() *QMetaClassInfo
|
|
}
|
|
|
|
func (p *QMetaClassInfo) QMetaClassInfo_PTR() *QMetaClassInfo {
|
|
return p
|
|
}
|
|
|
|
func (p *QMetaClassInfo) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMetaClassInfo) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMetaClassInfo(ptr QMetaClassInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaClassInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMetaClassInfoFromPointer(ptr unsafe.Pointer) *QMetaClassInfo {
|
|
var n = new(QMetaClassInfo)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMetaClassInfoFromPointer(ptr unsafe.Pointer) *QMetaClassInfo {
|
|
var n = NewQMetaClassInfoFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QMetaClassInfo) Name() string {
|
|
defer qt.Recovering("QMetaClassInfo::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaClassInfo_Name(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMetaClassInfo) Value() string {
|
|
defer qt.Recovering("QMetaClassInfo::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaClassInfo_Value(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type QMetaEnum struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMetaEnum_ITF interface {
|
|
QMetaEnum_PTR() *QMetaEnum
|
|
}
|
|
|
|
func (p *QMetaEnum) QMetaEnum_PTR() *QMetaEnum {
|
|
return p
|
|
}
|
|
|
|
func (p *QMetaEnum) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMetaEnum) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMetaEnum(ptr QMetaEnum_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaEnum_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMetaEnumFromPointer(ptr unsafe.Pointer) *QMetaEnum {
|
|
var n = new(QMetaEnum)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMetaEnumFromPointer(ptr unsafe.Pointer) *QMetaEnum {
|
|
var n = NewQMetaEnumFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QMetaEnum) IsFlag() bool {
|
|
defer qt.Recovering("QMetaEnum::isFlag")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaEnum_IsFlag(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaEnum) IsValid() bool {
|
|
defer qt.Recovering("QMetaEnum::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaEnum_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaEnum) Key(index int) string {
|
|
defer qt.Recovering("QMetaEnum::key")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaEnum_Key(ptr.Pointer(), C.int(index)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMetaEnum) KeyCount() int {
|
|
defer qt.Recovering("QMetaEnum::keyCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaEnum_KeyCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaEnum) KeyToValue(key string, ok bool) int {
|
|
defer qt.Recovering("QMetaEnum::keyToValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaEnum_KeyToValue(ptr.Pointer(), C.CString(key), C.int(qt.GoBoolToInt(ok))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaEnum) KeysToValue(keys string, ok bool) int {
|
|
defer qt.Recovering("QMetaEnum::keysToValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaEnum_KeysToValue(ptr.Pointer(), C.CString(keys), C.int(qt.GoBoolToInt(ok))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaEnum) Name() string {
|
|
defer qt.Recovering("QMetaEnum::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaEnum_Name(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMetaEnum) Scope() string {
|
|
defer qt.Recovering("QMetaEnum::scope")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaEnum_Scope(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMetaEnum) Value(index int) int {
|
|
defer qt.Recovering("QMetaEnum::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaEnum_Value(ptr.Pointer(), C.int(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaEnum) ValueToKey(value int) string {
|
|
defer qt.Recovering("QMetaEnum::valueToKey")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaEnum_ValueToKey(ptr.Pointer(), C.int(value)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMetaEnum) ValueToKeys(value int) string {
|
|
defer qt.Recovering("QMetaEnum::valueToKeys")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaEnum_ValueToKeys(ptr.Pointer(), C.int(value)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//QMetaMethod::Access
|
|
type QMetaMethod__Access int64
|
|
|
|
const (
|
|
QMetaMethod__Private = QMetaMethod__Access(0)
|
|
QMetaMethod__Protected = QMetaMethod__Access(1)
|
|
QMetaMethod__Public = QMetaMethod__Access(2)
|
|
)
|
|
|
|
//QMetaMethod::MethodType
|
|
type QMetaMethod__MethodType int64
|
|
|
|
const (
|
|
QMetaMethod__Method = QMetaMethod__MethodType(0)
|
|
QMetaMethod__Signal = QMetaMethod__MethodType(1)
|
|
QMetaMethod__Slot = QMetaMethod__MethodType(2)
|
|
QMetaMethod__Constructor = QMetaMethod__MethodType(3)
|
|
)
|
|
|
|
type QMetaMethod struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMetaMethod_ITF interface {
|
|
QMetaMethod_PTR() *QMetaMethod
|
|
}
|
|
|
|
func (p *QMetaMethod) QMetaMethod_PTR() *QMetaMethod {
|
|
return p
|
|
}
|
|
|
|
func (p *QMetaMethod) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMetaMethod) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMetaMethod(ptr QMetaMethod_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaMethod_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMetaMethodFromPointer(ptr unsafe.Pointer) *QMetaMethod {
|
|
var n = new(QMetaMethod)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMetaMethodFromPointer(ptr unsafe.Pointer) *QMetaMethod {
|
|
var n = NewQMetaMethodFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QMetaMethod) Access() QMetaMethod__Access {
|
|
defer qt.Recovering("QMetaMethod::access")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QMetaMethod__Access(C.QMetaMethod_Access(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaMethod) Invoke4(object QObject_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaMethod::invoke")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaMethod_Invoke4(ptr.Pointer(), PointerFromQObject(object), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaMethod) Invoke2(object QObject_ITF, returnValue QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaMethod::invoke")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaMethod_Invoke2(ptr.Pointer(), PointerFromQObject(object), PointerFromQGenericReturnArgument(returnValue), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaMethod) Invoke3(object QObject_ITF, connectionType Qt__ConnectionType, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaMethod::invoke")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaMethod_Invoke3(ptr.Pointer(), PointerFromQObject(object), C.int(connectionType), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaMethod) Invoke(object QObject_ITF, connectionType Qt__ConnectionType, returnValue QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaMethod::invoke")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaMethod_Invoke(ptr.Pointer(), PointerFromQObject(object), C.int(connectionType), PointerFromQGenericReturnArgument(returnValue), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaMethod) InvokeOnGadget2(gadget unsafe.Pointer, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaMethod::invokeOnGadget")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaMethod_InvokeOnGadget2(ptr.Pointer(), gadget, PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaMethod) InvokeOnGadget(gadget unsafe.Pointer, returnValue QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaMethod::invokeOnGadget")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaMethod_InvokeOnGadget(ptr.Pointer(), gadget, PointerFromQGenericReturnArgument(returnValue), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaMethod) IsValid() bool {
|
|
defer qt.Recovering("QMetaMethod::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaMethod_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaMethod) MethodIndex() int {
|
|
defer qt.Recovering("QMetaMethod::methodIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaMethod_MethodIndex(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaMethod) MethodSignature() string {
|
|
defer qt.Recovering("QMetaMethod::methodSignature")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaMethod_MethodSignature(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMetaMethod) MethodType() QMetaMethod__MethodType {
|
|
defer qt.Recovering("QMetaMethod::methodType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QMetaMethod__MethodType(C.QMetaMethod_MethodType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaMethod) Name() string {
|
|
defer qt.Recovering("QMetaMethod::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaMethod_Name(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMetaMethod) ParameterCount() int {
|
|
defer qt.Recovering("QMetaMethod::parameterCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaMethod_ParameterCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaMethod) ParameterType(index int) int {
|
|
defer qt.Recovering("QMetaMethod::parameterType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaMethod_ParameterType(ptr.Pointer(), C.int(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaMethod) ReturnType() int {
|
|
defer qt.Recovering("QMetaMethod::returnType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaMethod_ReturnType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaMethod) Revision() int {
|
|
defer qt.Recovering("QMetaMethod::revision")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaMethod_Revision(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaMethod) Tag() string {
|
|
defer qt.Recovering("QMetaMethod::tag")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaMethod_Tag(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMetaMethod) TypeName() string {
|
|
defer qt.Recovering("QMetaMethod::typeName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaMethod_TypeName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type QMetaObject struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMetaObject_ITF interface {
|
|
QMetaObject_PTR() *QMetaObject
|
|
}
|
|
|
|
func (p *QMetaObject) QMetaObject_PTR() *QMetaObject {
|
|
return p
|
|
}
|
|
|
|
func (p *QMetaObject) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMetaObject) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMetaObject(ptr QMetaObject_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMetaObjectFromPointer(ptr unsafe.Pointer) *QMetaObject {
|
|
var n = new(QMetaObject)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMetaObjectFromPointer(ptr unsafe.Pointer) *QMetaObject {
|
|
var n = NewQMetaObjectFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func QMetaObject_ConnectSlotsByName(object QObject_ITF) {
|
|
defer qt.Recovering("QMetaObject::connectSlotsByName")
|
|
|
|
C.QMetaObject_QMetaObject_ConnectSlotsByName(PointerFromQObject(object))
|
|
}
|
|
|
|
func (ptr *QMetaObject) ConnectSlotsByName(object QObject_ITF) {
|
|
defer qt.Recovering("QMetaObject::connectSlotsByName")
|
|
|
|
C.QMetaObject_QMetaObject_ConnectSlotsByName(PointerFromQObject(object))
|
|
}
|
|
|
|
func QMetaObject_CheckConnectArgs2(sign QMetaMethod_ITF, method QMetaMethod_ITF) bool {
|
|
defer qt.Recovering("QMetaObject::checkConnectArgs")
|
|
|
|
return C.QMetaObject_QMetaObject_CheckConnectArgs2(PointerFromQMetaMethod(sign), PointerFromQMetaMethod(method)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) CheckConnectArgs2(sign QMetaMethod_ITF, method QMetaMethod_ITF) bool {
|
|
defer qt.Recovering("QMetaObject::checkConnectArgs")
|
|
|
|
return C.QMetaObject_QMetaObject_CheckConnectArgs2(PointerFromQMetaMethod(sign), PointerFromQMetaMethod(method)) != 0
|
|
}
|
|
|
|
func QMetaObject_CheckConnectArgs(sign string, method string) bool {
|
|
defer qt.Recovering("QMetaObject::checkConnectArgs")
|
|
|
|
return C.QMetaObject_QMetaObject_CheckConnectArgs(C.CString(sign), C.CString(method)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) CheckConnectArgs(sign string, method string) bool {
|
|
defer qt.Recovering("QMetaObject::checkConnectArgs")
|
|
|
|
return C.QMetaObject_QMetaObject_CheckConnectArgs(C.CString(sign), C.CString(method)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) ClassInfoCount() int {
|
|
defer qt.Recovering("QMetaObject::classInfoCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_ClassInfoCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) ClassInfoOffset() int {
|
|
defer qt.Recovering("QMetaObject::classInfoOffset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_ClassInfoOffset(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) ClassName() string {
|
|
defer qt.Recovering("QMetaObject::className")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaObject_ClassName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMetaObject) Constructor(index int) *QMetaMethod {
|
|
defer qt.Recovering("QMetaObject::constructor")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaMethodFromPointer(C.QMetaObject_Constructor(ptr.Pointer(), C.int(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMetaObject) ConstructorCount() int {
|
|
defer qt.Recovering("QMetaObject::constructorCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_ConstructorCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) EnumeratorCount() int {
|
|
defer qt.Recovering("QMetaObject::enumeratorCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_EnumeratorCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) EnumeratorOffset() int {
|
|
defer qt.Recovering("QMetaObject::enumeratorOffset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_EnumeratorOffset(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) IndexOfClassInfo(name string) int {
|
|
defer qt.Recovering("QMetaObject::indexOfClassInfo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_IndexOfClassInfo(ptr.Pointer(), C.CString(name)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) IndexOfConstructor(constructor string) int {
|
|
defer qt.Recovering("QMetaObject::indexOfConstructor")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_IndexOfConstructor(ptr.Pointer(), C.CString(constructor)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) IndexOfEnumerator(name string) int {
|
|
defer qt.Recovering("QMetaObject::indexOfEnumerator")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_IndexOfEnumerator(ptr.Pointer(), C.CString(name)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) IndexOfMethod(method string) int {
|
|
defer qt.Recovering("QMetaObject::indexOfMethod")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_IndexOfMethod(ptr.Pointer(), C.CString(method)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) IndexOfProperty(name string) int {
|
|
defer qt.Recovering("QMetaObject::indexOfProperty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_IndexOfProperty(ptr.Pointer(), C.CString(name)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) IndexOfSignal(sign string) int {
|
|
defer qt.Recovering("QMetaObject::indexOfSignal")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_IndexOfSignal(ptr.Pointer(), C.CString(sign)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) IndexOfSlot(slot string) int {
|
|
defer qt.Recovering("QMetaObject::indexOfSlot")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_IndexOfSlot(ptr.Pointer(), C.CString(slot)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QMetaObject_InvokeMethod4(obj QObject_ITF, member string, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaObject::invokeMethod")
|
|
|
|
return C.QMetaObject_QMetaObject_InvokeMethod4(PointerFromQObject(obj), C.CString(member), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) InvokeMethod4(obj QObject_ITF, member string, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaObject::invokeMethod")
|
|
|
|
return C.QMetaObject_QMetaObject_InvokeMethod4(PointerFromQObject(obj), C.CString(member), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
|
|
func QMetaObject_InvokeMethod2(obj QObject_ITF, member string, ret QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaObject::invokeMethod")
|
|
|
|
return C.QMetaObject_QMetaObject_InvokeMethod2(PointerFromQObject(obj), C.CString(member), PointerFromQGenericReturnArgument(ret), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) InvokeMethod2(obj QObject_ITF, member string, ret QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaObject::invokeMethod")
|
|
|
|
return C.QMetaObject_QMetaObject_InvokeMethod2(PointerFromQObject(obj), C.CString(member), PointerFromQGenericReturnArgument(ret), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
|
|
func QMetaObject_InvokeMethod3(obj QObject_ITF, member string, ty Qt__ConnectionType, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaObject::invokeMethod")
|
|
|
|
return C.QMetaObject_QMetaObject_InvokeMethod3(PointerFromQObject(obj), C.CString(member), C.int(ty), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) InvokeMethod3(obj QObject_ITF, member string, ty Qt__ConnectionType, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaObject::invokeMethod")
|
|
|
|
return C.QMetaObject_QMetaObject_InvokeMethod3(PointerFromQObject(obj), C.CString(member), C.int(ty), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
|
|
func QMetaObject_InvokeMethod(obj QObject_ITF, member string, ty Qt__ConnectionType, ret QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaObject::invokeMethod")
|
|
|
|
return C.QMetaObject_QMetaObject_InvokeMethod(PointerFromQObject(obj), C.CString(member), C.int(ty), PointerFromQGenericReturnArgument(ret), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) InvokeMethod(obj QObject_ITF, member string, ty Qt__ConnectionType, ret QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
|
|
defer qt.Recovering("QMetaObject::invokeMethod")
|
|
|
|
return C.QMetaObject_QMetaObject_InvokeMethod(PointerFromQObject(obj), C.CString(member), C.int(ty), PointerFromQGenericReturnArgument(ret), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) Method(index int) *QMetaMethod {
|
|
defer qt.Recovering("QMetaObject::method")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaMethodFromPointer(C.QMetaObject_Method(ptr.Pointer(), C.int(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMetaObject) MethodCount() int {
|
|
defer qt.Recovering("QMetaObject::methodCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_MethodCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) MethodOffset() int {
|
|
defer qt.Recovering("QMetaObject::methodOffset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_MethodOffset(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) NewInstance(val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) *QObject {
|
|
defer qt.Recovering("QMetaObject::newInstance")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QMetaObject_NewInstance(ptr.Pointer(), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func QMetaObject_NormalizedSignature(method string) string {
|
|
defer qt.Recovering("QMetaObject::normalizedSignature")
|
|
|
|
return C.GoString(C.QMetaObject_QMetaObject_NormalizedSignature(C.CString(method)))
|
|
}
|
|
|
|
func (ptr *QMetaObject) NormalizedSignature(method string) string {
|
|
defer qt.Recovering("QMetaObject::normalizedSignature")
|
|
|
|
return C.GoString(C.QMetaObject_QMetaObject_NormalizedSignature(C.CString(method)))
|
|
}
|
|
|
|
func QMetaObject_NormalizedType(ty string) string {
|
|
defer qt.Recovering("QMetaObject::normalizedType")
|
|
|
|
return C.GoString(C.QMetaObject_QMetaObject_NormalizedType(C.CString(ty)))
|
|
}
|
|
|
|
func (ptr *QMetaObject) NormalizedType(ty string) string {
|
|
defer qt.Recovering("QMetaObject::normalizedType")
|
|
|
|
return C.GoString(C.QMetaObject_QMetaObject_NormalizedType(C.CString(ty)))
|
|
}
|
|
|
|
func (ptr *QMetaObject) PropertyCount() int {
|
|
defer qt.Recovering("QMetaObject::propertyCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_PropertyCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) PropertyOffset() int {
|
|
defer qt.Recovering("QMetaObject::propertyOffset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaObject_PropertyOffset(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaObject) SuperClass() *QMetaObject {
|
|
defer qt.Recovering("QMetaObject::superClass")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QMetaObject_SuperClass(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QMetaProperty struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMetaProperty_ITF interface {
|
|
QMetaProperty_PTR() *QMetaProperty
|
|
}
|
|
|
|
func (p *QMetaProperty) QMetaProperty_PTR() *QMetaProperty {
|
|
return p
|
|
}
|
|
|
|
func (p *QMetaProperty) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMetaProperty) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMetaProperty(ptr QMetaProperty_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaProperty_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMetaPropertyFromPointer(ptr unsafe.Pointer) *QMetaProperty {
|
|
var n = new(QMetaProperty)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMetaPropertyFromPointer(ptr unsafe.Pointer) *QMetaProperty {
|
|
var n = NewQMetaPropertyFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QMetaProperty) HasNotifySignal() bool {
|
|
defer qt.Recovering("QMetaProperty::hasNotifySignal")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_HasNotifySignal(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) IsConstant() bool {
|
|
defer qt.Recovering("QMetaProperty::isConstant")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_IsConstant(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) IsDesignable(object QObject_ITF) bool {
|
|
defer qt.Recovering("QMetaProperty::isDesignable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_IsDesignable(ptr.Pointer(), PointerFromQObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) IsEnumType() bool {
|
|
defer qt.Recovering("QMetaProperty::isEnumType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_IsEnumType(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) IsFinal() bool {
|
|
defer qt.Recovering("QMetaProperty::isFinal")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_IsFinal(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) IsFlagType() bool {
|
|
defer qt.Recovering("QMetaProperty::isFlagType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_IsFlagType(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) IsReadable() bool {
|
|
defer qt.Recovering("QMetaProperty::isReadable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_IsReadable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) IsResettable() bool {
|
|
defer qt.Recovering("QMetaProperty::isResettable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_IsResettable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) IsScriptable(object QObject_ITF) bool {
|
|
defer qt.Recovering("QMetaProperty::isScriptable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_IsScriptable(ptr.Pointer(), PointerFromQObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) IsStored(object QObject_ITF) bool {
|
|
defer qt.Recovering("QMetaProperty::isStored")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_IsStored(ptr.Pointer(), PointerFromQObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) IsUser(object QObject_ITF) bool {
|
|
defer qt.Recovering("QMetaProperty::isUser")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_IsUser(ptr.Pointer(), PointerFromQObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) IsValid() bool {
|
|
defer qt.Recovering("QMetaProperty::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) IsWritable() bool {
|
|
defer qt.Recovering("QMetaProperty::isWritable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_IsWritable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) Name() string {
|
|
defer qt.Recovering("QMetaProperty::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaProperty_Name(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMetaProperty) NotifySignal() *QMetaMethod {
|
|
defer qt.Recovering("QMetaProperty::notifySignal")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaMethodFromPointer(C.QMetaProperty_NotifySignal(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMetaProperty) NotifySignalIndex() int {
|
|
defer qt.Recovering("QMetaProperty::notifySignalIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaProperty_NotifySignalIndex(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaProperty) PropertyIndex() int {
|
|
defer qt.Recovering("QMetaProperty::propertyIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaProperty_PropertyIndex(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaProperty) Read(object QObject_ITF) *QVariant {
|
|
defer qt.Recovering("QMetaProperty::read")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QMetaProperty_Read(ptr.Pointer(), PointerFromQObject(object)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMetaProperty) ReadOnGadget(gadget unsafe.Pointer) *QVariant {
|
|
defer qt.Recovering("QMetaProperty::readOnGadget")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QMetaProperty_ReadOnGadget(ptr.Pointer(), gadget))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMetaProperty) Reset(object QObject_ITF) bool {
|
|
defer qt.Recovering("QMetaProperty::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_Reset(ptr.Pointer(), PointerFromQObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) ResetOnGadget(gadget unsafe.Pointer) bool {
|
|
defer qt.Recovering("QMetaProperty::resetOnGadget")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_ResetOnGadget(ptr.Pointer(), gadget) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) Revision() int {
|
|
defer qt.Recovering("QMetaProperty::revision")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaProperty_Revision(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaProperty) TypeName() string {
|
|
defer qt.Recovering("QMetaProperty::typeName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMetaProperty_TypeName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMetaProperty) UserType() int {
|
|
defer qt.Recovering("QMetaProperty::userType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaProperty_UserType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMetaProperty) Write(object QObject_ITF, value QVariant_ITF) bool {
|
|
defer qt.Recovering("QMetaProperty::write")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_Write(ptr.Pointer(), PointerFromQObject(object), PointerFromQVariant(value)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaProperty) WriteOnGadget(gadget unsafe.Pointer, value QVariant_ITF) bool {
|
|
defer qt.Recovering("QMetaProperty::writeOnGadget")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaProperty_WriteOnGadget(ptr.Pointer(), gadget, PointerFromQVariant(value)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//QMetaType::Type
|
|
type QMetaType__Type int64
|
|
|
|
const (
|
|
QMetaType__UnknownType = QMetaType__Type(0)
|
|
QMetaType__Bool = QMetaType__Type(1)
|
|
QMetaType__Int = QMetaType__Type(2)
|
|
QMetaType__UInt = QMetaType__Type(3)
|
|
QMetaType__LongLong = QMetaType__Type(4)
|
|
QMetaType__ULongLong = QMetaType__Type(5)
|
|
QMetaType__Double = QMetaType__Type(6)
|
|
QMetaType__Long = QMetaType__Type(32)
|
|
QMetaType__Short = QMetaType__Type(33)
|
|
QMetaType__Char = QMetaType__Type(34)
|
|
QMetaType__ULong = QMetaType__Type(35)
|
|
QMetaType__UShort = QMetaType__Type(36)
|
|
QMetaType__UChar = QMetaType__Type(37)
|
|
QMetaType__Float = QMetaType__Type(38)
|
|
QMetaType__VoidStar = QMetaType__Type(31)
|
|
QMetaType__QChar = QMetaType__Type(7)
|
|
QMetaType__QString = QMetaType__Type(10)
|
|
QMetaType__QStringList = QMetaType__Type(11)
|
|
QMetaType__QByteArray = QMetaType__Type(12)
|
|
QMetaType__QBitArray = QMetaType__Type(13)
|
|
QMetaType__QDate = QMetaType__Type(14)
|
|
QMetaType__QTime = QMetaType__Type(15)
|
|
QMetaType__QDateTime = QMetaType__Type(16)
|
|
QMetaType__QUrl = QMetaType__Type(17)
|
|
QMetaType__QLocale = QMetaType__Type(18)
|
|
QMetaType__QRect = QMetaType__Type(19)
|
|
QMetaType__QRectF = QMetaType__Type(20)
|
|
QMetaType__QSize = QMetaType__Type(21)
|
|
QMetaType__QSizeF = QMetaType__Type(22)
|
|
QMetaType__QLine = QMetaType__Type(23)
|
|
QMetaType__QLineF = QMetaType__Type(24)
|
|
QMetaType__QPoint = QMetaType__Type(25)
|
|
QMetaType__QPointF = QMetaType__Type(26)
|
|
QMetaType__QRegExp = QMetaType__Type(27)
|
|
QMetaType__QEasingCurve = QMetaType__Type(29)
|
|
QMetaType__QUuid = QMetaType__Type(30)
|
|
QMetaType__QVariant = QMetaType__Type(41)
|
|
QMetaType__QModelIndex = QMetaType__Type(42)
|
|
QMetaType__QPersistentModelIndex = QMetaType__Type(50)
|
|
QMetaType__QRegularExpression = QMetaType__Type(44)
|
|
QMetaType__QJsonValue = QMetaType__Type(45)
|
|
QMetaType__QJsonObject = QMetaType__Type(46)
|
|
QMetaType__QJsonArray = QMetaType__Type(47)
|
|
QMetaType__QJsonDocument = QMetaType__Type(48)
|
|
QMetaType__QByteArrayList = QMetaType__Type(49)
|
|
QMetaType__QObjectStar = QMetaType__Type(39)
|
|
QMetaType__SChar = QMetaType__Type(40)
|
|
QMetaType__Void = QMetaType__Type(43)
|
|
QMetaType__QVariantMap = QMetaType__Type(8)
|
|
QMetaType__QVariantList = QMetaType__Type(9)
|
|
QMetaType__QVariantHash = QMetaType__Type(28)
|
|
QMetaType__QFont = QMetaType__Type(64)
|
|
QMetaType__QPixmap = QMetaType__Type(65)
|
|
QMetaType__QBrush = QMetaType__Type(66)
|
|
QMetaType__QColor = QMetaType__Type(67)
|
|
QMetaType__QPalette = QMetaType__Type(68)
|
|
QMetaType__QIcon = QMetaType__Type(69)
|
|
QMetaType__QImage = QMetaType__Type(70)
|
|
QMetaType__QPolygon = QMetaType__Type(71)
|
|
QMetaType__QRegion = QMetaType__Type(72)
|
|
QMetaType__QBitmap = QMetaType__Type(73)
|
|
QMetaType__QCursor = QMetaType__Type(74)
|
|
QMetaType__QKeySequence = QMetaType__Type(75)
|
|
QMetaType__QPen = QMetaType__Type(76)
|
|
QMetaType__QTextLength = QMetaType__Type(77)
|
|
QMetaType__QTextFormat = QMetaType__Type(78)
|
|
QMetaType__QMatrix = QMetaType__Type(79)
|
|
QMetaType__QTransform = QMetaType__Type(80)
|
|
QMetaType__QMatrix4x4 = QMetaType__Type(81)
|
|
QMetaType__QVector2D = QMetaType__Type(82)
|
|
QMetaType__QVector3D = QMetaType__Type(83)
|
|
QMetaType__QVector4D = QMetaType__Type(84)
|
|
QMetaType__QQuaternion = QMetaType__Type(85)
|
|
QMetaType__QPolygonF = QMetaType__Type(86)
|
|
QMetaType__QSizePolicy = QMetaType__Type(121)
|
|
QMetaType__User = QMetaType__Type(1024)
|
|
)
|
|
|
|
//QMetaType::TypeFlag
|
|
type QMetaType__TypeFlag int64
|
|
|
|
const (
|
|
QMetaType__NeedsConstruction = QMetaType__TypeFlag(0x1)
|
|
QMetaType__NeedsDestruction = QMetaType__TypeFlag(0x2)
|
|
QMetaType__MovableType = QMetaType__TypeFlag(0x4)
|
|
QMetaType__PointerToQObject = QMetaType__TypeFlag(0x8)
|
|
QMetaType__IsEnumeration = QMetaType__TypeFlag(0x10)
|
|
QMetaType__SharedPointerToQObject = QMetaType__TypeFlag(0x20)
|
|
QMetaType__WeakPointerToQObject = QMetaType__TypeFlag(0x40)
|
|
QMetaType__TrackingPointerToQObject = QMetaType__TypeFlag(0x80)
|
|
QMetaType__WasDeclaredAsMetaType = QMetaType__TypeFlag(0x100)
|
|
QMetaType__IsGadget = QMetaType__TypeFlag(0x200)
|
|
)
|
|
|
|
type QMetaType struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMetaType_ITF interface {
|
|
QMetaType_PTR() *QMetaType
|
|
}
|
|
|
|
func (p *QMetaType) QMetaType_PTR() *QMetaType {
|
|
return p
|
|
}
|
|
|
|
func (p *QMetaType) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMetaType) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMetaType(ptr QMetaType_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaType_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMetaTypeFromPointer(ptr unsafe.Pointer) *QMetaType {
|
|
var n = new(QMetaType)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMetaTypeFromPointer(ptr unsafe.Pointer) *QMetaType {
|
|
var n = NewQMetaTypeFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQMetaType(typeId int) *QMetaType {
|
|
defer qt.Recovering("QMetaType::QMetaType")
|
|
|
|
return newQMetaTypeFromPointer(C.QMetaType_NewQMetaType(C.int(typeId)))
|
|
}
|
|
|
|
func QMetaType_Compare(lhs unsafe.Pointer, rhs unsafe.Pointer, typeId int, result int) bool {
|
|
defer qt.Recovering("QMetaType::compare")
|
|
|
|
return C.QMetaType_QMetaType_Compare(lhs, rhs, C.int(typeId), C.int(result)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaType) Compare(lhs unsafe.Pointer, rhs unsafe.Pointer, typeId int, result int) bool {
|
|
defer qt.Recovering("QMetaType::compare")
|
|
|
|
return C.QMetaType_QMetaType_Compare(lhs, rhs, C.int(typeId), C.int(result)) != 0
|
|
}
|
|
|
|
func QMetaType_Construct(ty int, where unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("QMetaType::construct")
|
|
|
|
return unsafe.Pointer(C.QMetaType_QMetaType_Construct(C.int(ty), where, copy))
|
|
}
|
|
|
|
func (ptr *QMetaType) Construct(ty int, where unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("QMetaType::construct")
|
|
|
|
return unsafe.Pointer(C.QMetaType_QMetaType_Construct(C.int(ty), where, copy))
|
|
}
|
|
|
|
func (ptr *QMetaType) Construct3(where unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("QMetaType::construct")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QMetaType_Construct3(ptr.Pointer(), where, copy))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func QMetaType_Convert(from unsafe.Pointer, fromTypeId int, to unsafe.Pointer, toTypeId int) bool {
|
|
defer qt.Recovering("QMetaType::convert")
|
|
|
|
return C.QMetaType_QMetaType_Convert(from, C.int(fromTypeId), to, C.int(toTypeId)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaType) Convert(from unsafe.Pointer, fromTypeId int, to unsafe.Pointer, toTypeId int) bool {
|
|
defer qt.Recovering("QMetaType::convert")
|
|
|
|
return C.QMetaType_QMetaType_Convert(from, C.int(fromTypeId), to, C.int(toTypeId)) != 0
|
|
}
|
|
|
|
func QMetaType_Create(ty int, copy unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("QMetaType::create")
|
|
|
|
return unsafe.Pointer(C.QMetaType_QMetaType_Create(C.int(ty), copy))
|
|
}
|
|
|
|
func (ptr *QMetaType) Create(ty int, copy unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("QMetaType::create")
|
|
|
|
return unsafe.Pointer(C.QMetaType_QMetaType_Create(C.int(ty), copy))
|
|
}
|
|
|
|
func (ptr *QMetaType) Create2(copy unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("QMetaType::create")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QMetaType_Create2(ptr.Pointer(), copy))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func QMetaType_DebugStream(dbg QDebug_ITF, rhs unsafe.Pointer, typeId int) bool {
|
|
defer qt.Recovering("QMetaType::debugStream")
|
|
|
|
return C.QMetaType_QMetaType_DebugStream(PointerFromQDebug(dbg), rhs, C.int(typeId)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaType) DebugStream(dbg QDebug_ITF, rhs unsafe.Pointer, typeId int) bool {
|
|
defer qt.Recovering("QMetaType::debugStream")
|
|
|
|
return C.QMetaType_QMetaType_DebugStream(PointerFromQDebug(dbg), rhs, C.int(typeId)) != 0
|
|
}
|
|
|
|
func QMetaType_Destroy(ty int, data unsafe.Pointer) {
|
|
defer qt.Recovering("QMetaType::destroy")
|
|
|
|
C.QMetaType_QMetaType_Destroy(C.int(ty), data)
|
|
}
|
|
|
|
func (ptr *QMetaType) Destroy(ty int, data unsafe.Pointer) {
|
|
defer qt.Recovering("QMetaType::destroy")
|
|
|
|
C.QMetaType_QMetaType_Destroy(C.int(ty), data)
|
|
}
|
|
|
|
func (ptr *QMetaType) Destroy2(data unsafe.Pointer) {
|
|
defer qt.Recovering("QMetaType::destroy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaType_Destroy2(ptr.Pointer(), data)
|
|
}
|
|
}
|
|
|
|
func QMetaType_Destruct(ty int, where unsafe.Pointer) {
|
|
defer qt.Recovering("QMetaType::destruct")
|
|
|
|
C.QMetaType_QMetaType_Destruct(C.int(ty), where)
|
|
}
|
|
|
|
func (ptr *QMetaType) Destruct(ty int, where unsafe.Pointer) {
|
|
defer qt.Recovering("QMetaType::destruct")
|
|
|
|
C.QMetaType_QMetaType_Destruct(C.int(ty), where)
|
|
}
|
|
|
|
func (ptr *QMetaType) Destruct2(data unsafe.Pointer) {
|
|
defer qt.Recovering("QMetaType::destruct")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaType_Destruct2(ptr.Pointer(), data)
|
|
}
|
|
}
|
|
|
|
func QMetaType_Equals(lhs unsafe.Pointer, rhs unsafe.Pointer, typeId int, result int) bool {
|
|
defer qt.Recovering("QMetaType::equals")
|
|
|
|
return C.QMetaType_QMetaType_Equals(lhs, rhs, C.int(typeId), C.int(result)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaType) Equals(lhs unsafe.Pointer, rhs unsafe.Pointer, typeId int, result int) bool {
|
|
defer qt.Recovering("QMetaType::equals")
|
|
|
|
return C.QMetaType_QMetaType_Equals(lhs, rhs, C.int(typeId), C.int(result)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaType) Flags() QMetaType__TypeFlag {
|
|
defer qt.Recovering("QMetaType::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QMetaType__TypeFlag(C.QMetaType_Flags(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QMetaType_IsRegistered(ty int) bool {
|
|
defer qt.Recovering("QMetaType::isRegistered")
|
|
|
|
return C.QMetaType_QMetaType_IsRegistered(C.int(ty)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaType) IsRegistered(ty int) bool {
|
|
defer qt.Recovering("QMetaType::isRegistered")
|
|
|
|
return C.QMetaType_QMetaType_IsRegistered(C.int(ty)) != 0
|
|
}
|
|
|
|
func (ptr *QMetaType) IsRegistered2() bool {
|
|
defer qt.Recovering("QMetaType::isRegistered")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaType_IsRegistered2(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMetaType) IsValid() bool {
|
|
defer qt.Recovering("QMetaType::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaType_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QMetaType_Load(stream QDataStream_ITF, ty int, data unsafe.Pointer) bool {
|
|
defer qt.Recovering("QMetaType::load")
|
|
|
|
return C.QMetaType_QMetaType_Load(PointerFromQDataStream(stream), C.int(ty), data) != 0
|
|
}
|
|
|
|
func (ptr *QMetaType) Load(stream QDataStream_ITF, ty int, data unsafe.Pointer) bool {
|
|
defer qt.Recovering("QMetaType::load")
|
|
|
|
return C.QMetaType_QMetaType_Load(PointerFromQDataStream(stream), C.int(ty), data) != 0
|
|
}
|
|
|
|
func (ptr *QMetaType) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QMetaType::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QMetaType_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func QMetaType_MetaObjectForType(ty int) *QMetaObject {
|
|
defer qt.Recovering("QMetaType::metaObjectForType")
|
|
|
|
return NewQMetaObjectFromPointer(C.QMetaType_QMetaType_MetaObjectForType(C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QMetaType) MetaObjectForType(ty int) *QMetaObject {
|
|
defer qt.Recovering("QMetaType::metaObjectForType")
|
|
|
|
return NewQMetaObjectFromPointer(C.QMetaType_QMetaType_MetaObjectForType(C.int(ty)))
|
|
}
|
|
|
|
func QMetaType_Save(stream QDataStream_ITF, ty int, data unsafe.Pointer) bool {
|
|
defer qt.Recovering("QMetaType::save")
|
|
|
|
return C.QMetaType_QMetaType_Save(PointerFromQDataStream(stream), C.int(ty), data) != 0
|
|
}
|
|
|
|
func (ptr *QMetaType) Save(stream QDataStream_ITF, ty int, data unsafe.Pointer) bool {
|
|
defer qt.Recovering("QMetaType::save")
|
|
|
|
return C.QMetaType_QMetaType_Save(PointerFromQDataStream(stream), C.int(ty), data) != 0
|
|
}
|
|
|
|
func QMetaType_SizeOf(ty int) int {
|
|
defer qt.Recovering("QMetaType::sizeOf")
|
|
|
|
return int(C.QMetaType_QMetaType_SizeOf(C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QMetaType) SizeOf(ty int) int {
|
|
defer qt.Recovering("QMetaType::sizeOf")
|
|
|
|
return int(C.QMetaType_QMetaType_SizeOf(C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QMetaType) SizeOf2() int {
|
|
defer qt.Recovering("QMetaType::sizeOf")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QMetaType_SizeOf2(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QMetaType_Type2(typeName string) int {
|
|
defer qt.Recovering("QMetaType::type")
|
|
|
|
return int(C.QMetaType_QMetaType_Type2(C.CString(typeName)))
|
|
}
|
|
|
|
func (ptr *QMetaType) Type2(typeName string) int {
|
|
defer qt.Recovering("QMetaType::type")
|
|
|
|
return int(C.QMetaType_QMetaType_Type2(C.CString(typeName)))
|
|
}
|
|
|
|
func QMetaType_Type(typeName string) int {
|
|
defer qt.Recovering("QMetaType::type")
|
|
|
|
return int(C.QMetaType_QMetaType_Type(C.CString(typeName)))
|
|
}
|
|
|
|
func (ptr *QMetaType) Type(typeName string) int {
|
|
defer qt.Recovering("QMetaType::type")
|
|
|
|
return int(C.QMetaType_QMetaType_Type(C.CString(typeName)))
|
|
}
|
|
|
|
func QMetaType_TypeFlags(ty int) QMetaType__TypeFlag {
|
|
defer qt.Recovering("QMetaType::typeFlags")
|
|
|
|
return QMetaType__TypeFlag(C.QMetaType_QMetaType_TypeFlags(C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QMetaType) TypeFlags(ty int) QMetaType__TypeFlag {
|
|
defer qt.Recovering("QMetaType::typeFlags")
|
|
|
|
return QMetaType__TypeFlag(C.QMetaType_QMetaType_TypeFlags(C.int(ty)))
|
|
}
|
|
|
|
func QMetaType_TypeName(typeId int) string {
|
|
defer qt.Recovering("QMetaType::typeName")
|
|
|
|
return C.GoString(C.QMetaType_QMetaType_TypeName(C.int(typeId)))
|
|
}
|
|
|
|
func (ptr *QMetaType) TypeName(typeId int) string {
|
|
defer qt.Recovering("QMetaType::typeName")
|
|
|
|
return C.GoString(C.QMetaType_QMetaType_TypeName(C.int(typeId)))
|
|
}
|
|
|
|
func (ptr *QMetaType) DestroyQMetaType() {
|
|
defer qt.Recovering("QMetaType::~QMetaType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaType_DestroyQMetaType(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QMimeData struct {
|
|
QObject
|
|
}
|
|
|
|
type QMimeData_ITF interface {
|
|
QObject_ITF
|
|
QMimeData_PTR() *QMimeData
|
|
}
|
|
|
|
func (p *QMimeData) QMimeData_PTR() *QMimeData {
|
|
return p
|
|
}
|
|
|
|
func (p *QMimeData) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMimeData) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMimeData(ptr QMimeData_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMimeData_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMimeDataFromPointer(ptr unsafe.Pointer) *QMimeData {
|
|
var n = new(QMimeData)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMimeDataFromPointer(ptr unsafe.Pointer) *QMimeData {
|
|
var n = NewQMimeDataFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QMimeData_") {
|
|
n.SetObjectName("QMimeData_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQMimeData() *QMimeData {
|
|
defer qt.Recovering("QMimeData::QMimeData")
|
|
|
|
return newQMimeDataFromPointer(C.QMimeData_NewQMimeData())
|
|
}
|
|
|
|
func (ptr *QMimeData) Clear() {
|
|
defer qt.Recovering("QMimeData::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) ColorData() *QVariant {
|
|
defer qt.Recovering("QMimeData::colorData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QMimeData_ColorData(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMimeData) Data(mimeType string) string {
|
|
defer qt.Recovering("QMimeData::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMimeData_Data(ptr.Pointer(), C.CString(mimeType)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQMimeData_Formats
|
|
func callbackQMimeData_Formats(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QMimeData::formats")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "formats"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(NewQMimeDataFromPointer(ptr).FormatsDefault(), "|"))
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectFormats(f func() []string) {
|
|
defer qt.Recovering("connect QMimeData::formats")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "formats", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectFormats() {
|
|
defer qt.Recovering("disconnect QMimeData::formats")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "formats")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) Formats() []string {
|
|
defer qt.Recovering("QMimeData::formats")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QMimeData_Formats(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMimeData) FormatsDefault() []string {
|
|
defer qt.Recovering("QMimeData::formats")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QMimeData_FormatsDefault(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMimeData) HasColor() bool {
|
|
defer qt.Recovering("QMimeData::hasColor")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeData_HasColor(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMimeData_HasFormat
|
|
func callbackQMimeData_HasFormat(ptr unsafe.Pointer, ptrName *C.char, mimeType *C.char) C.int {
|
|
defer qt.Recovering("callback QMimeData::hasFormat")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "hasFormat"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(string) bool)(C.GoString(mimeType))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQMimeDataFromPointer(ptr).HasFormatDefault(C.GoString(mimeType))))
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectHasFormat(f func(mimeType string) bool) {
|
|
defer qt.Recovering("connect QMimeData::hasFormat")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "hasFormat", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectHasFormat() {
|
|
defer qt.Recovering("disconnect QMimeData::hasFormat")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "hasFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) HasFormat(mimeType string) bool {
|
|
defer qt.Recovering("QMimeData::hasFormat")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeData_HasFormat(ptr.Pointer(), C.CString(mimeType)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMimeData) HasFormatDefault(mimeType string) bool {
|
|
defer qt.Recovering("QMimeData::hasFormat")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeData_HasFormatDefault(ptr.Pointer(), C.CString(mimeType)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMimeData) HasHtml() bool {
|
|
defer qt.Recovering("QMimeData::hasHtml")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeData_HasHtml(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMimeData) HasImage() bool {
|
|
defer qt.Recovering("QMimeData::hasImage")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeData_HasImage(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMimeData) HasText() bool {
|
|
defer qt.Recovering("QMimeData::hasText")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeData_HasText(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMimeData) HasUrls() bool {
|
|
defer qt.Recovering("QMimeData::hasUrls")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeData_HasUrls(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMimeData) Html() string {
|
|
defer qt.Recovering("QMimeData::html")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMimeData_Html(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMimeData) ImageData() *QVariant {
|
|
defer qt.Recovering("QMimeData::imageData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QMimeData_ImageData(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMimeData) RemoveFormat(mimeType string) {
|
|
defer qt.Recovering("QMimeData::removeFormat")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_RemoveFormat(ptr.Pointer(), C.CString(mimeType))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) SetColorData(color QVariant_ITF) {
|
|
defer qt.Recovering("QMimeData::setColorData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_SetColorData(ptr.Pointer(), PointerFromQVariant(color))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) SetData(mimeType string, data string) {
|
|
defer qt.Recovering("QMimeData::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_SetData(ptr.Pointer(), C.CString(mimeType), C.CString(data))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) SetHtml(html string) {
|
|
defer qt.Recovering("QMimeData::setHtml")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_SetHtml(ptr.Pointer(), C.CString(html))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) SetImageData(image QVariant_ITF) {
|
|
defer qt.Recovering("QMimeData::setImageData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_SetImageData(ptr.Pointer(), PointerFromQVariant(image))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) SetText(text string) {
|
|
defer qt.Recovering("QMimeData::setText")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_SetText(ptr.Pointer(), C.CString(text))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) Text() string {
|
|
defer qt.Recovering("QMimeData::text")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMimeData_Text(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMimeData) DestroyQMimeData() {
|
|
defer qt.Recovering("QMimeData::~QMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QMimeData_DestroyQMimeData(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMimeData_TimerEvent
|
|
func callbackQMimeData_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QMimeData::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQMimeDataFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QMimeData::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QMimeData::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QMimeData::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QMimeData::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMimeData_ChildEvent
|
|
func callbackQMimeData_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QMimeData::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQMimeDataFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QMimeData::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QMimeData::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QMimeData::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QMimeData::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMimeData_ConnectNotify
|
|
func callbackQMimeData_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QMimeData::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMimeDataFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QMimeData::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QMimeData::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QMimeData::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QMimeData::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMimeData_CustomEvent
|
|
func callbackQMimeData_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QMimeData::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQMimeDataFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QMimeData::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QMimeData::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QMimeData::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QMimeData::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMimeData_DeleteLater
|
|
func callbackQMimeData_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QMimeData::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMimeDataFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QMimeData::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QMimeData::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DeleteLater() {
|
|
defer qt.Recovering("QMimeData::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QMimeData_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DeleteLaterDefault() {
|
|
defer qt.Recovering("QMimeData::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QMimeData_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMimeData_DisconnectNotify
|
|
func callbackQMimeData_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QMimeData::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMimeDataFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QMimeData::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QMimeData::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QMimeData::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QMimeData::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeData_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMimeData_Event
|
|
func callbackQMimeData_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QMimeData::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQMimeDataFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QMimeData::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QMimeData::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QMimeData::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeData_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMimeData) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QMimeData::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeData_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMimeData_EventFilter
|
|
func callbackQMimeData_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QMimeData::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQMimeDataFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QMimeData::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QMimeData::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QMimeData::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeData_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMimeData) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QMimeData::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeData_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMimeData_MetaObject
|
|
func callbackQMimeData_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QMimeData::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQMimeDataFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QMimeData) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QMimeData::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QMimeData::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeData) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QMimeData::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QMimeData_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMimeData) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QMimeData::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QMimeData_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//QMimeDatabase::MatchMode
|
|
type QMimeDatabase__MatchMode int64
|
|
|
|
const (
|
|
QMimeDatabase__MatchDefault = QMimeDatabase__MatchMode(0x0)
|
|
QMimeDatabase__MatchExtension = QMimeDatabase__MatchMode(0x1)
|
|
QMimeDatabase__MatchContent = QMimeDatabase__MatchMode(0x2)
|
|
)
|
|
|
|
type QMimeDatabase struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMimeDatabase_ITF interface {
|
|
QMimeDatabase_PTR() *QMimeDatabase
|
|
}
|
|
|
|
func (p *QMimeDatabase) QMimeDatabase_PTR() *QMimeDatabase {
|
|
return p
|
|
}
|
|
|
|
func (p *QMimeDatabase) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMimeDatabase) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMimeDatabase(ptr QMimeDatabase_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMimeDatabase_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMimeDatabaseFromPointer(ptr unsafe.Pointer) *QMimeDatabase {
|
|
var n = new(QMimeDatabase)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMimeDatabaseFromPointer(ptr unsafe.Pointer) *QMimeDatabase {
|
|
var n = NewQMimeDatabaseFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQMimeDatabase() *QMimeDatabase {
|
|
defer qt.Recovering("QMimeDatabase::QMimeDatabase")
|
|
|
|
return newQMimeDatabaseFromPointer(C.QMimeDatabase_NewQMimeDatabase())
|
|
}
|
|
|
|
func (ptr *QMimeDatabase) MimeTypeForName(nameOrAlias string) *QMimeType {
|
|
defer qt.Recovering("QMimeDatabase::mimeTypeForName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForName(ptr.Pointer(), C.CString(nameOrAlias)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMimeDatabase) DestroyQMimeDatabase() {
|
|
defer qt.Recovering("QMimeDatabase::~QMimeDatabase")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeDatabase_DestroyQMimeDatabase(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeDatabase) MimeTypeForData2(device QIODevice_ITF) *QMimeType {
|
|
defer qt.Recovering("QMimeDatabase::mimeTypeForData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForData2(ptr.Pointer(), PointerFromQIODevice(device)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMimeDatabase) MimeTypeForData(data string) *QMimeType {
|
|
defer qt.Recovering("QMimeDatabase::mimeTypeForData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForData(ptr.Pointer(), C.CString(data)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMimeDatabase) MimeTypeForFile(fileInfo QFileInfo_ITF, mode QMimeDatabase__MatchMode) *QMimeType {
|
|
defer qt.Recovering("QMimeDatabase::mimeTypeForFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForFile(ptr.Pointer(), PointerFromQFileInfo(fileInfo), C.int(mode)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMimeDatabase) MimeTypeForFile2(fileName string, mode QMimeDatabase__MatchMode) *QMimeType {
|
|
defer qt.Recovering("QMimeDatabase::mimeTypeForFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForFile2(ptr.Pointer(), C.CString(fileName), C.int(mode)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMimeDatabase) MimeTypeForFileNameAndData(fileName string, device QIODevice_ITF) *QMimeType {
|
|
defer qt.Recovering("QMimeDatabase::mimeTypeForFileNameAndData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForFileNameAndData(ptr.Pointer(), C.CString(fileName), PointerFromQIODevice(device)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMimeDatabase) MimeTypeForFileNameAndData2(fileName string, data string) *QMimeType {
|
|
defer qt.Recovering("QMimeDatabase::mimeTypeForFileNameAndData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForFileNameAndData2(ptr.Pointer(), C.CString(fileName), C.CString(data)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMimeDatabase) MimeTypeForUrl(url QUrl_ITF) *QMimeType {
|
|
defer qt.Recovering("QMimeDatabase::mimeTypeForUrl")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForUrl(ptr.Pointer(), PointerFromQUrl(url)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMimeDatabase) SuffixForFileName(fileName string) string {
|
|
defer qt.Recovering("QMimeDatabase::suffixForFileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMimeDatabase_SuffixForFileName(ptr.Pointer(), C.CString(fileName)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type QMimeType struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMimeType_ITF interface {
|
|
QMimeType_PTR() *QMimeType
|
|
}
|
|
|
|
func (p *QMimeType) QMimeType_PTR() *QMimeType {
|
|
return p
|
|
}
|
|
|
|
func (p *QMimeType) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMimeType) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMimeType(ptr QMimeType_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMimeType_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMimeTypeFromPointer(ptr unsafe.Pointer) *QMimeType {
|
|
var n = new(QMimeType)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMimeTypeFromPointer(ptr unsafe.Pointer) *QMimeType {
|
|
var n = NewQMimeTypeFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQMimeType() *QMimeType {
|
|
defer qt.Recovering("QMimeType::QMimeType")
|
|
|
|
return newQMimeTypeFromPointer(C.QMimeType_NewQMimeType())
|
|
}
|
|
|
|
func NewQMimeType2(other QMimeType_ITF) *QMimeType {
|
|
defer qt.Recovering("QMimeType::QMimeType")
|
|
|
|
return newQMimeTypeFromPointer(C.QMimeType_NewQMimeType2(PointerFromQMimeType(other)))
|
|
}
|
|
|
|
func (ptr *QMimeType) FilterString() string {
|
|
defer qt.Recovering("QMimeType::filterString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMimeType_FilterString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMimeType) GenericIconName() string {
|
|
defer qt.Recovering("QMimeType::genericIconName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMimeType_GenericIconName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMimeType) GlobPatterns() []string {
|
|
defer qt.Recovering("QMimeType::globPatterns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QMimeType_GlobPatterns(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMimeType) IconName() string {
|
|
defer qt.Recovering("QMimeType::iconName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMimeType_IconName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMimeType) Inherits(mimeTypeName string) bool {
|
|
defer qt.Recovering("QMimeType::inherits")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeType_Inherits(ptr.Pointer(), C.CString(mimeTypeName)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMimeType) IsDefault() bool {
|
|
defer qt.Recovering("QMimeType::isDefault")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeType_IsDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMimeType) IsValid() bool {
|
|
defer qt.Recovering("QMimeType::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMimeType_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMimeType) Name() string {
|
|
defer qt.Recovering("QMimeType::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMimeType_Name(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMimeType) DestroyQMimeType() {
|
|
defer qt.Recovering("QMimeType::~QMimeType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeType_DestroyQMimeType(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMimeType) Aliases() []string {
|
|
defer qt.Recovering("QMimeType::aliases")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QMimeType_Aliases(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMimeType) AllAncestors() []string {
|
|
defer qt.Recovering("QMimeType::allAncestors")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QMimeType_AllAncestors(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMimeType) Comment() string {
|
|
defer qt.Recovering("QMimeType::comment")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMimeType_Comment(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMimeType) ParentMimeTypes() []string {
|
|
defer qt.Recovering("QMimeType::parentMimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QMimeType_ParentMimeTypes(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMimeType) PreferredSuffix() string {
|
|
defer qt.Recovering("QMimeType::preferredSuffix")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QMimeType_PreferredSuffix(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMimeType) Suffixes() []string {
|
|
defer qt.Recovering("QMimeType::suffixes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QMimeType_Suffixes(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMimeType) Swap(other QMimeType_ITF) {
|
|
defer qt.Recovering("QMimeType::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMimeType_Swap(ptr.Pointer(), PointerFromQMimeType(other))
|
|
}
|
|
}
|
|
|
|
type QModelIndex struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QModelIndex_ITF interface {
|
|
QModelIndex_PTR() *QModelIndex
|
|
}
|
|
|
|
func (p *QModelIndex) QModelIndex_PTR() *QModelIndex {
|
|
return p
|
|
}
|
|
|
|
func (p *QModelIndex) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QModelIndex) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQModelIndex(ptr QModelIndex_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QModelIndex_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQModelIndexFromPointer(ptr unsafe.Pointer) *QModelIndex {
|
|
var n = new(QModelIndex)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQModelIndexFromPointer(ptr unsafe.Pointer) *QModelIndex {
|
|
var n = NewQModelIndexFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQModelIndex() *QModelIndex {
|
|
defer qt.Recovering("QModelIndex::QModelIndex")
|
|
|
|
return newQModelIndexFromPointer(C.QModelIndex_NewQModelIndex())
|
|
}
|
|
|
|
func (ptr *QModelIndex) Child(row int, column int) *QModelIndex {
|
|
defer qt.Recovering("QModelIndex::child")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QModelIndex_Child(ptr.Pointer(), C.int(row), C.int(column)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QModelIndex) Column() int {
|
|
defer qt.Recovering("QModelIndex::column")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QModelIndex_Column(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QModelIndex) Data(role int) *QVariant {
|
|
defer qt.Recovering("QModelIndex::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QModelIndex_Data(ptr.Pointer(), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QModelIndex) Flags() Qt__ItemFlag {
|
|
defer qt.Recovering("QModelIndex::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QModelIndex_Flags(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QModelIndex) InternalPointer() unsafe.Pointer {
|
|
defer qt.Recovering("QModelIndex::internalPointer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QModelIndex_InternalPointer(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QModelIndex) IsValid() bool {
|
|
defer qt.Recovering("QModelIndex::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QModelIndex_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QModelIndex) Model() *QAbstractItemModel {
|
|
defer qt.Recovering("QModelIndex::model")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractItemModelFromPointer(C.QModelIndex_Model(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QModelIndex) Parent() *QModelIndex {
|
|
defer qt.Recovering("QModelIndex::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QModelIndex_Parent(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QModelIndex) Row() int {
|
|
defer qt.Recovering("QModelIndex::row")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QModelIndex_Row(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QModelIndex) Sibling(row int, column int) *QModelIndex {
|
|
defer qt.Recovering("QModelIndex::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QModelIndex_Sibling(ptr.Pointer(), C.int(row), C.int(column)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//QModulesPrivate::Names
|
|
type QModulesPrivate__Names int64
|
|
|
|
const (
|
|
QModulesPrivate__Core = QModulesPrivate__Names(0)
|
|
QModulesPrivate__Gui = QModulesPrivate__Names(1)
|
|
QModulesPrivate__Widgets = QModulesPrivate__Names(2)
|
|
QModulesPrivate__Unknown = QModulesPrivate__Names(3)
|
|
QModulesPrivate__ModulesCount = QModulesPrivate__Names(4)
|
|
)
|
|
|
|
type QModulesPrivate struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QModulesPrivate_ITF interface {
|
|
QModulesPrivate_PTR() *QModulesPrivate
|
|
}
|
|
|
|
func (p *QModulesPrivate) QModulesPrivate_PTR() *QModulesPrivate {
|
|
return p
|
|
}
|
|
|
|
func (p *QModulesPrivate) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QModulesPrivate) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQModulesPrivate(ptr QModulesPrivate_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QModulesPrivate_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQModulesPrivateFromPointer(ptr unsafe.Pointer) *QModulesPrivate {
|
|
var n = new(QModulesPrivate)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQModulesPrivateFromPointer(ptr unsafe.Pointer) *QModulesPrivate {
|
|
var n = NewQModulesPrivateFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QMultiHash struct {
|
|
QHash
|
|
}
|
|
|
|
type QMultiHash_ITF interface {
|
|
QHash_ITF
|
|
QMultiHash_PTR() *QMultiHash
|
|
}
|
|
|
|
func (p *QMultiHash) QMultiHash_PTR() *QMultiHash {
|
|
return p
|
|
}
|
|
|
|
func (p *QMultiHash) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QHash_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMultiHash) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QHash_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMultiHash(ptr QMultiHash_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMultiHash_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMultiHashFromPointer(ptr unsafe.Pointer) *QMultiHash {
|
|
var n = new(QMultiHash)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMultiHashFromPointer(ptr unsafe.Pointer) *QMultiHash {
|
|
var n = NewQMultiHashFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QMultiMap struct {
|
|
QMap
|
|
}
|
|
|
|
type QMultiMap_ITF interface {
|
|
QMap_ITF
|
|
QMultiMap_PTR() *QMultiMap
|
|
}
|
|
|
|
func (p *QMultiMap) QMultiMap_PTR() *QMultiMap {
|
|
return p
|
|
}
|
|
|
|
func (p *QMultiMap) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QMap_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMultiMap) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QMap_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMultiMap(ptr QMultiMap_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMultiMap_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMultiMapFromPointer(ptr unsafe.Pointer) *QMultiMap {
|
|
var n = new(QMultiMap)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMultiMapFromPointer(ptr unsafe.Pointer) *QMultiMap {
|
|
var n = NewQMultiMapFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QMutableHashIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMutableHashIterator_ITF interface {
|
|
QMutableHashIterator_PTR() *QMutableHashIterator
|
|
}
|
|
|
|
func (p *QMutableHashIterator) QMutableHashIterator_PTR() *QMutableHashIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QMutableHashIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMutableHashIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMutableHashIterator(ptr QMutableHashIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMutableHashIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMutableHashIteratorFromPointer(ptr unsafe.Pointer) *QMutableHashIterator {
|
|
var n = new(QMutableHashIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMutableHashIteratorFromPointer(ptr unsafe.Pointer) *QMutableHashIterator {
|
|
var n = NewQMutableHashIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QMutableLinkedListIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMutableLinkedListIterator_ITF interface {
|
|
QMutableLinkedListIterator_PTR() *QMutableLinkedListIterator
|
|
}
|
|
|
|
func (p *QMutableLinkedListIterator) QMutableLinkedListIterator_PTR() *QMutableLinkedListIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QMutableLinkedListIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMutableLinkedListIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMutableLinkedListIterator(ptr QMutableLinkedListIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMutableLinkedListIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMutableLinkedListIteratorFromPointer(ptr unsafe.Pointer) *QMutableLinkedListIterator {
|
|
var n = new(QMutableLinkedListIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMutableLinkedListIteratorFromPointer(ptr unsafe.Pointer) *QMutableLinkedListIterator {
|
|
var n = NewQMutableLinkedListIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QMutableListIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMutableListIterator_ITF interface {
|
|
QMutableListIterator_PTR() *QMutableListIterator
|
|
}
|
|
|
|
func (p *QMutableListIterator) QMutableListIterator_PTR() *QMutableListIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QMutableListIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMutableListIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMutableListIterator(ptr QMutableListIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMutableListIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMutableListIteratorFromPointer(ptr unsafe.Pointer) *QMutableListIterator {
|
|
var n = new(QMutableListIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMutableListIteratorFromPointer(ptr unsafe.Pointer) *QMutableListIterator {
|
|
var n = NewQMutableListIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QMutableMapIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMutableMapIterator_ITF interface {
|
|
QMutableMapIterator_PTR() *QMutableMapIterator
|
|
}
|
|
|
|
func (p *QMutableMapIterator) QMutableMapIterator_PTR() *QMutableMapIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QMutableMapIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMutableMapIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMutableMapIterator(ptr QMutableMapIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMutableMapIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMutableMapIteratorFromPointer(ptr unsafe.Pointer) *QMutableMapIterator {
|
|
var n = new(QMutableMapIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMutableMapIteratorFromPointer(ptr unsafe.Pointer) *QMutableMapIterator {
|
|
var n = NewQMutableMapIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QMutableSetIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMutableSetIterator_ITF interface {
|
|
QMutableSetIterator_PTR() *QMutableSetIterator
|
|
}
|
|
|
|
func (p *QMutableSetIterator) QMutableSetIterator_PTR() *QMutableSetIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QMutableSetIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMutableSetIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMutableSetIterator(ptr QMutableSetIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMutableSetIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMutableSetIteratorFromPointer(ptr unsafe.Pointer) *QMutableSetIterator {
|
|
var n = new(QMutableSetIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMutableSetIteratorFromPointer(ptr unsafe.Pointer) *QMutableSetIterator {
|
|
var n = NewQMutableSetIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QMutableVectorIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMutableVectorIterator_ITF interface {
|
|
QMutableVectorIterator_PTR() *QMutableVectorIterator
|
|
}
|
|
|
|
func (p *QMutableVectorIterator) QMutableVectorIterator_PTR() *QMutableVectorIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QMutableVectorIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMutableVectorIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMutableVectorIterator(ptr QMutableVectorIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMutableVectorIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMutableVectorIteratorFromPointer(ptr unsafe.Pointer) *QMutableVectorIterator {
|
|
var n = new(QMutableVectorIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMutableVectorIteratorFromPointer(ptr unsafe.Pointer) *QMutableVectorIterator {
|
|
var n = NewQMutableVectorIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QMutex::RecursionMode
|
|
type QMutex__RecursionMode int64
|
|
|
|
const (
|
|
QMutex__NonRecursive = QMutex__RecursionMode(0)
|
|
QMutex__Recursive = QMutex__RecursionMode(1)
|
|
)
|
|
|
|
type QMutex struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMutex_ITF interface {
|
|
QMutex_PTR() *QMutex
|
|
}
|
|
|
|
func (p *QMutex) QMutex_PTR() *QMutex {
|
|
return p
|
|
}
|
|
|
|
func (p *QMutex) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMutex) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMutex(ptr QMutex_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMutex_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMutexFromPointer(ptr unsafe.Pointer) *QMutex {
|
|
var n = new(QMutex)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMutexFromPointer(ptr unsafe.Pointer) *QMutex {
|
|
var n = NewQMutexFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QMutex) Lock() {
|
|
defer qt.Recovering("QMutex::lock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMutex_Lock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMutex) TryLock(timeout int) bool {
|
|
defer qt.Recovering("QMutex::tryLock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMutex_TryLock(ptr.Pointer(), C.int(timeout)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMutex) Unlock() {
|
|
defer qt.Recovering("QMutex::unlock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMutex_Unlock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func NewQMutex(mode QMutex__RecursionMode) *QMutex {
|
|
defer qt.Recovering("QMutex::QMutex")
|
|
|
|
return newQMutexFromPointer(C.QMutex_NewQMutex(C.int(mode)))
|
|
}
|
|
|
|
func (ptr *QMutex) IsRecursive() bool {
|
|
defer qt.Recovering("QMutex::isRecursive")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QMutex_IsRecursive(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QMutexLocker struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMutexLocker_ITF interface {
|
|
QMutexLocker_PTR() *QMutexLocker
|
|
}
|
|
|
|
func (p *QMutexLocker) QMutexLocker_PTR() *QMutexLocker {
|
|
return p
|
|
}
|
|
|
|
func (p *QMutexLocker) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QMutexLocker) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQMutexLocker(ptr QMutexLocker_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMutexLocker_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMutexLockerFromPointer(ptr unsafe.Pointer) *QMutexLocker {
|
|
var n = new(QMutexLocker)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQMutexLockerFromPointer(ptr unsafe.Pointer) *QMutexLocker {
|
|
var n = NewQMutexLockerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQMutexLocker(mutex QMutex_ITF) *QMutexLocker {
|
|
defer qt.Recovering("QMutexLocker::QMutexLocker")
|
|
|
|
return newQMutexLockerFromPointer(C.QMutexLocker_NewQMutexLocker(PointerFromQMutex(mutex)))
|
|
}
|
|
|
|
func (ptr *QMutexLocker) Mutex() *QMutex {
|
|
defer qt.Recovering("QMutexLocker::mutex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMutexFromPointer(C.QMutexLocker_Mutex(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMutexLocker) Relock() {
|
|
defer qt.Recovering("QMutexLocker::relock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMutexLocker_Relock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMutexLocker) Unlock() {
|
|
defer qt.Recovering("QMutexLocker::unlock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMutexLocker_Unlock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMutexLocker) DestroyQMutexLocker() {
|
|
defer qt.Recovering("QMutexLocker::~QMutexLocker")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QMutexLocker_DestroyQMutexLocker(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QObject struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QObject_ITF interface {
|
|
QObject_PTR() *QObject
|
|
}
|
|
|
|
func (p *QObject) QObject_PTR() *QObject {
|
|
return p
|
|
}
|
|
|
|
func (p *QObject) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QObject) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQObject(ptr QObject_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQObjectFromPointer(ptr unsafe.Pointer) *QObject {
|
|
var n = new(QObject)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQObjectFromPointer(ptr unsafe.Pointer) *QObject {
|
|
var n = NewQObjectFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QObject_") {
|
|
n.SetObjectName("QObject_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QObject) InstallEventFilter(filterObj QObject_ITF) {
|
|
defer qt.Recovering("QObject::installEventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_InstallEventFilter(ptr.Pointer(), PointerFromQObject(filterObj))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) ObjectName() string {
|
|
defer qt.Recovering("QObject::objectName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QObject_ObjectName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QObject) SetObjectName(name string) {
|
|
defer qt.Recovering("QObject::setObjectName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_SetObjectName(ptr.Pointer(), C.CString(name))
|
|
}
|
|
}
|
|
|
|
//export callbackQObject_TimerEvent
|
|
func callbackQObject_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QObject::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQObjectFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QObject::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QObject::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QObject::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QObject::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func NewQObject(parent QObject_ITF) *QObject {
|
|
defer qt.Recovering("QObject::QObject")
|
|
|
|
return newQObjectFromPointer(C.QObject_NewQObject(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QObject) BlockSignals(block bool) bool {
|
|
defer qt.Recovering("QObject::blockSignals")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_BlockSignals(ptr.Pointer(), C.int(qt.GoBoolToInt(block))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQObject_ChildEvent
|
|
func callbackQObject_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QObject::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQObjectFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QObject::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QObject::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QObject::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QObject::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQObject_ConnectNotify
|
|
func callbackQObject_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QObject::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQObjectFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QObject::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QObject::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QObject::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QObject::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQObject_CustomEvent
|
|
func callbackQObject_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QObject::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQObjectFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QObject::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QObject::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QObject::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QObject::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQObject_DeleteLater
|
|
func callbackQObject_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QObject::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QObject) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QObject::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QObject::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DeleteLater() {
|
|
defer qt.Recovering("QObject::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QObject_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQObject_Destroyed
|
|
func callbackQObject_Destroyed(ptr unsafe.Pointer, ptrName *C.char, obj unsafe.Pointer) {
|
|
defer qt.Recovering("callback QObject::destroyed")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "destroyed"); signal != nil {
|
|
signal.(func(*QObject))(NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QObject) ConnectDestroyed(f func(obj *QObject)) {
|
|
defer qt.Recovering("connect QObject::destroyed")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_ConnectDestroyed(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "destroyed", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectDestroyed() {
|
|
defer qt.Recovering("disconnect QObject::destroyed")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_DisconnectDestroyed(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "destroyed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) Destroyed(obj QObject_ITF) {
|
|
defer qt.Recovering("QObject::destroyed")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_Destroyed(ptr.Pointer(), PointerFromQObject(obj))
|
|
}
|
|
}
|
|
|
|
func QObject_Disconnect2(sender QObject_ITF, sign QMetaMethod_ITF, receiver QObject_ITF, method QMetaMethod_ITF) bool {
|
|
defer qt.Recovering("QObject::disconnect")
|
|
|
|
return C.QObject_QObject_Disconnect2(PointerFromQObject(sender), PointerFromQMetaMethod(sign), PointerFromQObject(receiver), PointerFromQMetaMethod(method)) != 0
|
|
}
|
|
|
|
func (ptr *QObject) Disconnect2(sender QObject_ITF, sign QMetaMethod_ITF, receiver QObject_ITF, method QMetaMethod_ITF) bool {
|
|
defer qt.Recovering("QObject::disconnect")
|
|
|
|
return C.QObject_QObject_Disconnect2(PointerFromQObject(sender), PointerFromQMetaMethod(sign), PointerFromQObject(receiver), PointerFromQMetaMethod(method)) != 0
|
|
}
|
|
|
|
func QObject_Disconnect(sender QObject_ITF, sign string, receiver QObject_ITF, method string) bool {
|
|
defer qt.Recovering("QObject::disconnect")
|
|
|
|
return C.QObject_QObject_Disconnect(PointerFromQObject(sender), C.CString(sign), PointerFromQObject(receiver), C.CString(method)) != 0
|
|
}
|
|
|
|
func (ptr *QObject) Disconnect(sender QObject_ITF, sign string, receiver QObject_ITF, method string) bool {
|
|
defer qt.Recovering("QObject::disconnect")
|
|
|
|
return C.QObject_QObject_Disconnect(PointerFromQObject(sender), C.CString(sign), PointerFromQObject(receiver), C.CString(method)) != 0
|
|
}
|
|
|
|
func (ptr *QObject) Disconnect4(receiver QObject_ITF, method string) bool {
|
|
defer qt.Recovering("QObject::disconnect")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_Disconnect4(ptr.Pointer(), PointerFromQObject(receiver), C.CString(method)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObject) Disconnect3(sign string, receiver QObject_ITF, method string) bool {
|
|
defer qt.Recovering("QObject::disconnect")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_Disconnect3(ptr.Pointer(), C.CString(sign), PointerFromQObject(receiver), C.CString(method)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQObject_DisconnectNotify
|
|
func callbackQObject_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QObject::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQObjectFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QObject::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QObject::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QObject::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QObject::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DumpObjectInfo() {
|
|
defer qt.Recovering("QObject::dumpObjectInfo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_DumpObjectInfo(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DumpObjectTree() {
|
|
defer qt.Recovering("QObject::dumpObjectTree")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_DumpObjectTree(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQObject_Event
|
|
func callbackQObject_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QObject::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQObjectFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QObject) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QObject::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QObject::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QObject::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObject) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QObject::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQObject_EventFilter
|
|
func callbackQObject_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QObject::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQObjectFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QObject) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QObject::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QObject::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QObject::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObject) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QObject::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObject) FindChild(name string, options Qt__FindChildOption) unsafe.Pointer {
|
|
defer qt.Recovering("QObject::findChild")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QObject_FindChild(ptr.Pointer(), C.CString(name), C.int(options)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QObject) Inherits(className string) bool {
|
|
defer qt.Recovering("QObject::inherits")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_Inherits(ptr.Pointer(), C.CString(className)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObject) IsSignalConnected(sign QMetaMethod_ITF) bool {
|
|
defer qt.Recovering("QObject::isSignalConnected")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_IsSignalConnected(ptr.Pointer(), PointerFromQMetaMethod(sign)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObject) IsWidgetType() bool {
|
|
defer qt.Recovering("QObject::isWidgetType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_IsWidgetType(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObject) IsWindowType() bool {
|
|
defer qt.Recovering("QObject::isWindowType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_IsWindowType(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObject) KillTimer(id int) {
|
|
defer qt.Recovering("QObject::killTimer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_KillTimer(ptr.Pointer(), C.int(id))
|
|
}
|
|
}
|
|
|
|
//export callbackQObject_MetaObject
|
|
func callbackQObject_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QObject::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQObjectFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QObject) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QObject::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QObject::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QObject::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QObject_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QObject) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QObject::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QObject_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QObject) MoveToThread(targetThread QThread_ITF) {
|
|
defer qt.Recovering("QObject::moveToThread")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_MoveToThread(ptr.Pointer(), PointerFromQThread(targetThread))
|
|
}
|
|
}
|
|
|
|
//export callbackQObject_ObjectNameChanged
|
|
func callbackQObject_ObjectNameChanged(ptr unsafe.Pointer, ptrName *C.char, objectName *C.char) {
|
|
defer qt.Recovering("callback QObject::objectNameChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(C.GoString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QObject) ConnectObjectNameChanged(f func(objectName string)) {
|
|
defer qt.Recovering("connect QObject::objectNameChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_ConnectObjectNameChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "objectNameChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) DisconnectObjectNameChanged() {
|
|
defer qt.Recovering("disconnect QObject::objectNameChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_DisconnectObjectNameChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "objectNameChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) Parent() *QObject {
|
|
defer qt.Recovering("QObject::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QObject_Parent(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QObject) Property(name string) *QVariant {
|
|
defer qt.Recovering("QObject::property")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QObject_Property(ptr.Pointer(), C.CString(name)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QObject) Receivers(sign string) int {
|
|
defer qt.Recovering("QObject::receivers")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QObject_Receivers(ptr.Pointer(), C.CString(sign)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QObject) RemoveEventFilter(obj QObject_ITF) {
|
|
defer qt.Recovering("QObject::removeEventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_RemoveEventFilter(ptr.Pointer(), PointerFromQObject(obj))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) Sender() *QObject {
|
|
defer qt.Recovering("QObject::sender")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QObject_Sender(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QObject) SenderSignalIndex() int {
|
|
defer qt.Recovering("QObject::senderSignalIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QObject_SenderSignalIndex(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QObject) SetParent(parent QObject_ITF) {
|
|
defer qt.Recovering("QObject::setParent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObject_SetParent(ptr.Pointer(), PointerFromQObject(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObject) SetProperty(name string, value QVariant_ITF) bool {
|
|
defer qt.Recovering("QObject::setProperty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_SetProperty(ptr.Pointer(), C.CString(name), PointerFromQVariant(value)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObject) SignalsBlocked() bool {
|
|
defer qt.Recovering("QObject::signalsBlocked")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObject_SignalsBlocked(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObject) StartTimer(interval int, timerType Qt__TimerType) int {
|
|
defer qt.Recovering("QObject::startTimer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QObject_StartTimer(ptr.Pointer(), C.int(interval), C.int(timerType)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QObject) Thread() *QThread {
|
|
defer qt.Recovering("QObject::thread")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQThreadFromPointer(C.QObject_Thread(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func QObject_Tr(sourceText string, disambiguation string, n int) string {
|
|
defer qt.Recovering("QObject::tr")
|
|
|
|
return C.GoString(C.QObject_QObject_Tr(C.CString(sourceText), C.CString(disambiguation), C.int(n)))
|
|
}
|
|
|
|
func (ptr *QObject) Tr(sourceText string, disambiguation string, n int) string {
|
|
defer qt.Recovering("QObject::tr")
|
|
|
|
return C.GoString(C.QObject_QObject_Tr(C.CString(sourceText), C.CString(disambiguation), C.int(n)))
|
|
}
|
|
|
|
func (ptr *QObject) DestroyQObject() {
|
|
defer qt.Recovering("QObject::~QObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QObject_DestroyQObject(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QObjectCleanupHandler struct {
|
|
QObject
|
|
}
|
|
|
|
type QObjectCleanupHandler_ITF interface {
|
|
QObject_ITF
|
|
QObjectCleanupHandler_PTR() *QObjectCleanupHandler
|
|
}
|
|
|
|
func (p *QObjectCleanupHandler) QObjectCleanupHandler_PTR() *QObjectCleanupHandler {
|
|
return p
|
|
}
|
|
|
|
func (p *QObjectCleanupHandler) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QObjectCleanupHandler) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQObjectCleanupHandler(ptr QObjectCleanupHandler_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObjectCleanupHandler_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQObjectCleanupHandlerFromPointer(ptr unsafe.Pointer) *QObjectCleanupHandler {
|
|
var n = new(QObjectCleanupHandler)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQObjectCleanupHandlerFromPointer(ptr unsafe.Pointer) *QObjectCleanupHandler {
|
|
var n = NewQObjectCleanupHandlerFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QObjectCleanupHandler_") {
|
|
n.SetObjectName("QObjectCleanupHandler_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQObjectCleanupHandler() *QObjectCleanupHandler {
|
|
defer qt.Recovering("QObjectCleanupHandler::QObjectCleanupHandler")
|
|
|
|
return newQObjectCleanupHandlerFromPointer(C.QObjectCleanupHandler_NewQObjectCleanupHandler())
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) Add(object QObject_ITF) *QObject {
|
|
defer qt.Recovering("QObjectCleanupHandler::add")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QObjectCleanupHandler_Add(ptr.Pointer(), PointerFromQObject(object)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) Clear() {
|
|
defer qt.Recovering("QObjectCleanupHandler::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) IsEmpty() bool {
|
|
defer qt.Recovering("QObjectCleanupHandler::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObjectCleanupHandler_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) Remove(object QObject_ITF) {
|
|
defer qt.Recovering("QObjectCleanupHandler::remove")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_Remove(ptr.Pointer(), PointerFromQObject(object))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DestroyQObjectCleanupHandler() {
|
|
defer qt.Recovering("QObjectCleanupHandler::~QObjectCleanupHandler")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_DestroyQObjectCleanupHandler(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQObjectCleanupHandler_TimerEvent
|
|
func callbackQObjectCleanupHandler_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QObjectCleanupHandler::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQObjectCleanupHandlerFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QObjectCleanupHandler::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QObjectCleanupHandler::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QObjectCleanupHandler::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QObjectCleanupHandler::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQObjectCleanupHandler_ChildEvent
|
|
func callbackQObjectCleanupHandler_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QObjectCleanupHandler::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQObjectCleanupHandlerFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QObjectCleanupHandler::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QObjectCleanupHandler::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QObjectCleanupHandler::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QObjectCleanupHandler::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQObjectCleanupHandler_ConnectNotify
|
|
func callbackQObjectCleanupHandler_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QObjectCleanupHandler::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQObjectCleanupHandlerFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QObjectCleanupHandler::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QObjectCleanupHandler::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QObjectCleanupHandler::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QObjectCleanupHandler::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQObjectCleanupHandler_CustomEvent
|
|
func callbackQObjectCleanupHandler_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QObjectCleanupHandler::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQObjectCleanupHandlerFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QObjectCleanupHandler::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QObjectCleanupHandler::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QObjectCleanupHandler::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QObjectCleanupHandler::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQObjectCleanupHandler_DeleteLater
|
|
func callbackQObjectCleanupHandler_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QObjectCleanupHandler::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQObjectCleanupHandlerFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QObjectCleanupHandler::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QObjectCleanupHandler::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DeleteLater() {
|
|
defer qt.Recovering("QObjectCleanupHandler::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DeleteLaterDefault() {
|
|
defer qt.Recovering("QObjectCleanupHandler::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQObjectCleanupHandler_DisconnectNotify
|
|
func callbackQObjectCleanupHandler_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QObjectCleanupHandler::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQObjectCleanupHandlerFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QObjectCleanupHandler::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QObjectCleanupHandler::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QObjectCleanupHandler::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QObjectCleanupHandler::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QObjectCleanupHandler_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQObjectCleanupHandler_Event
|
|
func callbackQObjectCleanupHandler_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QObjectCleanupHandler::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQObjectCleanupHandlerFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QObjectCleanupHandler::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QObjectCleanupHandler::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QObjectCleanupHandler::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObjectCleanupHandler_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QObjectCleanupHandler::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObjectCleanupHandler_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQObjectCleanupHandler_EventFilter
|
|
func callbackQObjectCleanupHandler_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QObjectCleanupHandler::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQObjectCleanupHandlerFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QObjectCleanupHandler::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QObjectCleanupHandler::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QObjectCleanupHandler::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObjectCleanupHandler_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QObjectCleanupHandler::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QObjectCleanupHandler_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQObjectCleanupHandler_MetaObject
|
|
func callbackQObjectCleanupHandler_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QObjectCleanupHandler::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQObjectCleanupHandlerFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QObjectCleanupHandler::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QObjectCleanupHandler::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QObjectCleanupHandler::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QObjectCleanupHandler_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QObjectCleanupHandler) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QObjectCleanupHandler::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QObjectCleanupHandler_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QPair struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QPair_ITF interface {
|
|
QPair_PTR() *QPair
|
|
}
|
|
|
|
func (p *QPair) QPair_PTR() *QPair {
|
|
return p
|
|
}
|
|
|
|
func (p *QPair) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QPair) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQPair(ptr QPair_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPair_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPairFromPointer(ptr unsafe.Pointer) *QPair {
|
|
var n = new(QPair)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQPairFromPointer(ptr unsafe.Pointer) *QPair {
|
|
var n = NewQPairFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QParallelAnimationGroup struct {
|
|
QAnimationGroup
|
|
}
|
|
|
|
type QParallelAnimationGroup_ITF interface {
|
|
QAnimationGroup_ITF
|
|
QParallelAnimationGroup_PTR() *QParallelAnimationGroup
|
|
}
|
|
|
|
func (p *QParallelAnimationGroup) QParallelAnimationGroup_PTR() *QParallelAnimationGroup {
|
|
return p
|
|
}
|
|
|
|
func (p *QParallelAnimationGroup) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAnimationGroup_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QParallelAnimationGroup) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAnimationGroup_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQParallelAnimationGroup(ptr QParallelAnimationGroup_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QParallelAnimationGroup_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQParallelAnimationGroupFromPointer(ptr unsafe.Pointer) *QParallelAnimationGroup {
|
|
var n = new(QParallelAnimationGroup)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQParallelAnimationGroupFromPointer(ptr unsafe.Pointer) *QParallelAnimationGroup {
|
|
var n = NewQParallelAnimationGroupFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QParallelAnimationGroup_") {
|
|
n.SetObjectName("QParallelAnimationGroup_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQParallelAnimationGroup(parent QObject_ITF) *QParallelAnimationGroup {
|
|
defer qt.Recovering("QParallelAnimationGroup::QParallelAnimationGroup")
|
|
|
|
return newQParallelAnimationGroupFromPointer(C.QParallelAnimationGroup_NewQParallelAnimationGroup(PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_Duration
|
|
func callbackQParallelAnimationGroup_Duration(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::duration")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "duration"); signal != nil {
|
|
return C.int(signal.(func() int)())
|
|
}
|
|
|
|
return C.int(NewQParallelAnimationGroupFromPointer(ptr).DurationDefault())
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectDuration(f func() int) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "duration", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectDuration() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) Duration() int {
|
|
defer qt.Recovering("QParallelAnimationGroup::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QParallelAnimationGroup_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DurationDefault() int {
|
|
defer qt.Recovering("QParallelAnimationGroup::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QParallelAnimationGroup_DurationDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_Event
|
|
func callbackQParallelAnimationGroup_Event(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQParallelAnimationGroupFromPointer(ptr).EventDefault(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectEvent(f func(event *QEvent) bool) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) Event(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QParallelAnimationGroup::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QParallelAnimationGroup_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) EventDefault(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QParallelAnimationGroup::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QParallelAnimationGroup_EventDefault(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_UpdateCurrentTime
|
|
func callbackQParallelAnimationGroup_UpdateCurrentTime(ptr unsafe.Pointer, ptrName *C.char, currentTime C.int) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::updateCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(currentTime))
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).UpdateCurrentTimeDefault(int(currentTime))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectUpdateCurrentTime(f func(currentTime int)) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectUpdateCurrentTime() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) UpdateCurrentTime(currentTime int) {
|
|
defer qt.Recovering("QParallelAnimationGroup::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_UpdateCurrentTime(ptr.Pointer(), C.int(currentTime))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) UpdateCurrentTimeDefault(currentTime int) {
|
|
defer qt.Recovering("QParallelAnimationGroup::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(currentTime))
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_UpdateDirection
|
|
func callbackQParallelAnimationGroup_UpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::updateDirection")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
|
|
signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectUpdateDirection() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateDirection")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) UpdateDirection(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QParallelAnimationGroup::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_UpdateDirection(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QParallelAnimationGroup::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_UpdateState
|
|
func callbackQParallelAnimationGroup_UpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::updateState")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
|
|
signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectUpdateState() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateState")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QParallelAnimationGroup::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QParallelAnimationGroup::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DestroyQParallelAnimationGroup() {
|
|
defer qt.Recovering("QParallelAnimationGroup::~QParallelAnimationGroup")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QParallelAnimationGroup_DestroyQParallelAnimationGroup(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_SetCurrentTime
|
|
func callbackQParallelAnimationGroup_SetCurrentTime(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::setCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(msecs))
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).SetCurrentTimeDefault(int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectSetCurrentTime(f func(msecs int)) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectSetCurrentTime() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) SetCurrentTime(msecs int) {
|
|
defer qt.Recovering("QParallelAnimationGroup::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_SetCurrentTime(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) SetCurrentTimeDefault(msecs int) {
|
|
defer qt.Recovering("QParallelAnimationGroup::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_SetCurrentTimeDefault(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_Pause
|
|
func callbackQParallelAnimationGroup_Pause(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::pause")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pause"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).PauseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectPause(f func()) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pause", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectPause() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pause")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) Pause() {
|
|
defer qt.Recovering("QParallelAnimationGroup::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_Pause(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) PauseDefault() {
|
|
defer qt.Recovering("QParallelAnimationGroup::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_PauseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_Resume
|
|
func callbackQParallelAnimationGroup_Resume(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::resume")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resume"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).ResumeDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectResume(f func()) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resume", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectResume() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) Resume() {
|
|
defer qt.Recovering("QParallelAnimationGroup::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_Resume(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ResumeDefault() {
|
|
defer qt.Recovering("QParallelAnimationGroup::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_ResumeDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_SetPaused
|
|
func callbackQParallelAnimationGroup_SetPaused(ptr unsafe.Pointer, ptrName *C.char, paused C.int) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::setPaused")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setPaused"); signal != nil {
|
|
signal.(func(bool))(int(paused) != 0)
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).SetPausedDefault(int(paused) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectSetPaused(f func(paused bool)) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setPaused", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectSetPaused() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setPaused")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) SetPaused(paused bool) {
|
|
defer qt.Recovering("QParallelAnimationGroup::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_SetPaused(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) SetPausedDefault(paused bool) {
|
|
defer qt.Recovering("QParallelAnimationGroup::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_SetPausedDefault(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_Start
|
|
func callbackQParallelAnimationGroup_Start(ptr unsafe.Pointer, ptrName *C.char, policy C.int) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::start")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "start"); signal != nil {
|
|
signal.(func(QAbstractAnimation__DeletionPolicy))(QAbstractAnimation__DeletionPolicy(policy))
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).StartDefault(QAbstractAnimation__DeletionPolicy(policy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectStart(f func(policy QAbstractAnimation__DeletionPolicy)) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "start", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectStart() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) Start(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QParallelAnimationGroup::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_Start(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) StartDefault(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QParallelAnimationGroup::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_StartDefault(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_Stop
|
|
func callbackQParallelAnimationGroup_Stop(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::stop")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectStop(f func()) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "stop", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectStop() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) Stop() {
|
|
defer qt.Recovering("QParallelAnimationGroup::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) StopDefault() {
|
|
defer qt.Recovering("QParallelAnimationGroup::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_TimerEvent
|
|
func callbackQParallelAnimationGroup_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QParallelAnimationGroup::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QParallelAnimationGroup::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_ChildEvent
|
|
func callbackQParallelAnimationGroup_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QParallelAnimationGroup::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QParallelAnimationGroup::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_ConnectNotify
|
|
func callbackQParallelAnimationGroup_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QParallelAnimationGroup::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QParallelAnimationGroup::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_CustomEvent
|
|
func callbackQParallelAnimationGroup_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QParallelAnimationGroup::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QParallelAnimationGroup::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_DeleteLater
|
|
func callbackQParallelAnimationGroup_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DeleteLater() {
|
|
defer qt.Recovering("QParallelAnimationGroup::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QParallelAnimationGroup_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DeleteLaterDefault() {
|
|
defer qt.Recovering("QParallelAnimationGroup::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QParallelAnimationGroup_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_DisconnectNotify
|
|
func callbackQParallelAnimationGroup_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQParallelAnimationGroupFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QParallelAnimationGroup::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QParallelAnimationGroup::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QParallelAnimationGroup_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_EventFilter
|
|
func callbackQParallelAnimationGroup_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQParallelAnimationGroupFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QParallelAnimationGroup::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QParallelAnimationGroup_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QParallelAnimationGroup::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QParallelAnimationGroup_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQParallelAnimationGroup_MetaObject
|
|
func callbackQParallelAnimationGroup_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QParallelAnimationGroup::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQParallelAnimationGroupFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QParallelAnimationGroup::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QParallelAnimationGroup::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QParallelAnimationGroup::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QParallelAnimationGroup_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QParallelAnimationGroup) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QParallelAnimationGroup::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QParallelAnimationGroup_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QPauseAnimation struct {
|
|
QAbstractAnimation
|
|
}
|
|
|
|
type QPauseAnimation_ITF interface {
|
|
QAbstractAnimation_ITF
|
|
QPauseAnimation_PTR() *QPauseAnimation
|
|
}
|
|
|
|
func (p *QPauseAnimation) QPauseAnimation_PTR() *QPauseAnimation {
|
|
return p
|
|
}
|
|
|
|
func (p *QPauseAnimation) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractAnimation_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QPauseAnimation) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractAnimation_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQPauseAnimation(ptr QPauseAnimation_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPauseAnimation_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPauseAnimationFromPointer(ptr unsafe.Pointer) *QPauseAnimation {
|
|
var n = new(QPauseAnimation)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQPauseAnimationFromPointer(ptr unsafe.Pointer) *QPauseAnimation {
|
|
var n = NewQPauseAnimationFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QPauseAnimation_") {
|
|
n.SetObjectName("QPauseAnimation_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
//export callbackQPauseAnimation_Duration
|
|
func callbackQPauseAnimation_Duration(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QPauseAnimation::duration")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "duration"); signal != nil {
|
|
return C.int(signal.(func() int)())
|
|
}
|
|
|
|
return C.int(NewQPauseAnimationFromPointer(ptr).DurationDefault())
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectDuration(f func() int) {
|
|
defer qt.Recovering("connect QPauseAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "duration", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectDuration() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) Duration() int {
|
|
defer qt.Recovering("QPauseAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QPauseAnimation_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DurationDefault() int {
|
|
defer qt.Recovering("QPauseAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QPauseAnimation_DurationDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) SetDuration(msecs int) {
|
|
defer qt.Recovering("QPauseAnimation::setDuration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_SetDuration(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
func NewQPauseAnimation(parent QObject_ITF) *QPauseAnimation {
|
|
defer qt.Recovering("QPauseAnimation::QPauseAnimation")
|
|
|
|
return newQPauseAnimationFromPointer(C.QPauseAnimation_NewQPauseAnimation(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQPauseAnimation2(msecs int, parent QObject_ITF) *QPauseAnimation {
|
|
defer qt.Recovering("QPauseAnimation::QPauseAnimation")
|
|
|
|
return newQPauseAnimationFromPointer(C.QPauseAnimation_NewQPauseAnimation2(C.int(msecs), PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQPauseAnimation_Event
|
|
func callbackQPauseAnimation_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QPauseAnimation::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQPauseAnimationFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QPauseAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QPauseAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPauseAnimation_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QPauseAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPauseAnimation_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQPauseAnimation_UpdateCurrentTime
|
|
func callbackQPauseAnimation_UpdateCurrentTime(ptr unsafe.Pointer, ptrName *C.char, vin C.int) {
|
|
defer qt.Recovering("callback QPauseAnimation::updateCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(vin))
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).UpdateCurrentTimeDefault(int(vin))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectUpdateCurrentTime(f func(vin int)) {
|
|
defer qt.Recovering("connect QPauseAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectUpdateCurrentTime() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) UpdateCurrentTime(vin int) {
|
|
defer qt.Recovering("QPauseAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_UpdateCurrentTime(ptr.Pointer(), C.int(vin))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) UpdateCurrentTimeDefault(vin int) {
|
|
defer qt.Recovering("QPauseAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(vin))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DestroyQPauseAnimation() {
|
|
defer qt.Recovering("QPauseAnimation::~QPauseAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QPauseAnimation_DestroyQPauseAnimation(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_SetCurrentTime
|
|
func callbackQPauseAnimation_SetCurrentTime(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) {
|
|
defer qt.Recovering("callback QPauseAnimation::setCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(msecs))
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).SetCurrentTimeDefault(int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectSetCurrentTime(f func(msecs int)) {
|
|
defer qt.Recovering("connect QPauseAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectSetCurrentTime() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) SetCurrentTime(msecs int) {
|
|
defer qt.Recovering("QPauseAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_SetCurrentTime(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) SetCurrentTimeDefault(msecs int) {
|
|
defer qt.Recovering("QPauseAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_SetCurrentTimeDefault(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_Pause
|
|
func callbackQPauseAnimation_Pause(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QPauseAnimation::pause")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pause"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).PauseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectPause(f func()) {
|
|
defer qt.Recovering("connect QPauseAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pause", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectPause() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pause")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) Pause() {
|
|
defer qt.Recovering("QPauseAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_Pause(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) PauseDefault() {
|
|
defer qt.Recovering("QPauseAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_PauseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_Resume
|
|
func callbackQPauseAnimation_Resume(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QPauseAnimation::resume")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resume"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).ResumeDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectResume(f func()) {
|
|
defer qt.Recovering("connect QPauseAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resume", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectResume() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) Resume() {
|
|
defer qt.Recovering("QPauseAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_Resume(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ResumeDefault() {
|
|
defer qt.Recovering("QPauseAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_ResumeDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_SetPaused
|
|
func callbackQPauseAnimation_SetPaused(ptr unsafe.Pointer, ptrName *C.char, paused C.int) {
|
|
defer qt.Recovering("callback QPauseAnimation::setPaused")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setPaused"); signal != nil {
|
|
signal.(func(bool))(int(paused) != 0)
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).SetPausedDefault(int(paused) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectSetPaused(f func(paused bool)) {
|
|
defer qt.Recovering("connect QPauseAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setPaused", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectSetPaused() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setPaused")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) SetPaused(paused bool) {
|
|
defer qt.Recovering("QPauseAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_SetPaused(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) SetPausedDefault(paused bool) {
|
|
defer qt.Recovering("QPauseAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_SetPausedDefault(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_Start
|
|
func callbackQPauseAnimation_Start(ptr unsafe.Pointer, ptrName *C.char, policy C.int) {
|
|
defer qt.Recovering("callback QPauseAnimation::start")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "start"); signal != nil {
|
|
signal.(func(QAbstractAnimation__DeletionPolicy))(QAbstractAnimation__DeletionPolicy(policy))
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).StartDefault(QAbstractAnimation__DeletionPolicy(policy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectStart(f func(policy QAbstractAnimation__DeletionPolicy)) {
|
|
defer qt.Recovering("connect QPauseAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "start", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectStart() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) Start(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QPauseAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_Start(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) StartDefault(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QPauseAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_StartDefault(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_Stop
|
|
func callbackQPauseAnimation_Stop(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QPauseAnimation::stop")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectStop(f func()) {
|
|
defer qt.Recovering("connect QPauseAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "stop", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectStop() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) Stop() {
|
|
defer qt.Recovering("QPauseAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) StopDefault() {
|
|
defer qt.Recovering("QPauseAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_UpdateDirection
|
|
func callbackQPauseAnimation_UpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
|
|
defer qt.Recovering("callback QPauseAnimation::updateDirection")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
|
|
signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
|
|
defer qt.Recovering("connect QPauseAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectUpdateDirection() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateDirection")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) UpdateDirection(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QPauseAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_UpdateDirection(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QPauseAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_UpdateState
|
|
func callbackQPauseAnimation_UpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
|
|
defer qt.Recovering("callback QPauseAnimation::updateState")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
|
|
signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
|
|
defer qt.Recovering("connect QPauseAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectUpdateState() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateState")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QPauseAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QPauseAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_TimerEvent
|
|
func callbackQPauseAnimation_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPauseAnimation::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QPauseAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QPauseAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QPauseAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_ChildEvent
|
|
func callbackQPauseAnimation_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPauseAnimation::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QPauseAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QPauseAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QPauseAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_ConnectNotify
|
|
func callbackQPauseAnimation_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPauseAnimation::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QPauseAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QPauseAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QPauseAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_CustomEvent
|
|
func callbackQPauseAnimation_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPauseAnimation::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QPauseAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QPauseAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QPauseAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_DeleteLater
|
|
func callbackQPauseAnimation_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QPauseAnimation::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QPauseAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DeleteLater() {
|
|
defer qt.Recovering("QPauseAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QPauseAnimation_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DeleteLaterDefault() {
|
|
defer qt.Recovering("QPauseAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QPauseAnimation_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_DisconnectNotify
|
|
func callbackQPauseAnimation_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPauseAnimation::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQPauseAnimationFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QPauseAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QPauseAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QPauseAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPauseAnimation_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQPauseAnimation_EventFilter
|
|
func callbackQPauseAnimation_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QPauseAnimation::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQPauseAnimationFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QPauseAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QPauseAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPauseAnimation_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QPauseAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPauseAnimation_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQPauseAnimation_MetaObject
|
|
func callbackQPauseAnimation_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QPauseAnimation::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQPauseAnimationFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QPauseAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QPauseAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QPauseAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QPauseAnimation_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPauseAnimation) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QPauseAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QPauseAnimation_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QPersistentModelIndex struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QPersistentModelIndex_ITF interface {
|
|
QPersistentModelIndex_PTR() *QPersistentModelIndex
|
|
}
|
|
|
|
func (p *QPersistentModelIndex) QPersistentModelIndex_PTR() *QPersistentModelIndex {
|
|
return p
|
|
}
|
|
|
|
func (p *QPersistentModelIndex) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QPersistentModelIndex) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQPersistentModelIndex(ptr QPersistentModelIndex_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPersistentModelIndex_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPersistentModelIndexFromPointer(ptr unsafe.Pointer) *QPersistentModelIndex {
|
|
var n = new(QPersistentModelIndex)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQPersistentModelIndexFromPointer(ptr unsafe.Pointer) *QPersistentModelIndex {
|
|
var n = NewQPersistentModelIndexFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQPersistentModelIndex3(other QPersistentModelIndex_ITF) *QPersistentModelIndex {
|
|
defer qt.Recovering("QPersistentModelIndex::QPersistentModelIndex")
|
|
|
|
return newQPersistentModelIndexFromPointer(C.QPersistentModelIndex_NewQPersistentModelIndex3(PointerFromQPersistentModelIndex(other)))
|
|
}
|
|
|
|
func (ptr *QPersistentModelIndex) Column() int {
|
|
defer qt.Recovering("QPersistentModelIndex::column")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QPersistentModelIndex_Column(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPersistentModelIndex) IsValid() bool {
|
|
defer qt.Recovering("QPersistentModelIndex::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPersistentModelIndex_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QPersistentModelIndex) Row() int {
|
|
defer qt.Recovering("QPersistentModelIndex::row")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QPersistentModelIndex_Row(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func NewQPersistentModelIndex4(other QPersistentModelIndex_ITF) *QPersistentModelIndex {
|
|
defer qt.Recovering("QPersistentModelIndex::QPersistentModelIndex")
|
|
|
|
return newQPersistentModelIndexFromPointer(C.QPersistentModelIndex_NewQPersistentModelIndex4(PointerFromQPersistentModelIndex(other)))
|
|
}
|
|
|
|
func NewQPersistentModelIndex(index QModelIndex_ITF) *QPersistentModelIndex {
|
|
defer qt.Recovering("QPersistentModelIndex::QPersistentModelIndex")
|
|
|
|
return newQPersistentModelIndexFromPointer(C.QPersistentModelIndex_NewQPersistentModelIndex(PointerFromQModelIndex(index)))
|
|
}
|
|
|
|
func (ptr *QPersistentModelIndex) Child(row int, column int) *QModelIndex {
|
|
defer qt.Recovering("QPersistentModelIndex::child")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QPersistentModelIndex_Child(ptr.Pointer(), C.int(row), C.int(column)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPersistentModelIndex) Data(role int) *QVariant {
|
|
defer qt.Recovering("QPersistentModelIndex::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QPersistentModelIndex_Data(ptr.Pointer(), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPersistentModelIndex) Flags() Qt__ItemFlag {
|
|
defer qt.Recovering("QPersistentModelIndex::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QPersistentModelIndex_Flags(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPersistentModelIndex) Model() *QAbstractItemModel {
|
|
defer qt.Recovering("QPersistentModelIndex::model")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractItemModelFromPointer(C.QPersistentModelIndex_Model(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPersistentModelIndex) Parent() *QModelIndex {
|
|
defer qt.Recovering("QPersistentModelIndex::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QPersistentModelIndex_Parent(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPersistentModelIndex) Sibling(row int, column int) *QModelIndex {
|
|
defer qt.Recovering("QPersistentModelIndex::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QPersistentModelIndex_Sibling(ptr.Pointer(), C.int(row), C.int(column)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPersistentModelIndex) Swap(other QPersistentModelIndex_ITF) {
|
|
defer qt.Recovering("QPersistentModelIndex::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPersistentModelIndex_Swap(ptr.Pointer(), PointerFromQPersistentModelIndex(other))
|
|
}
|
|
}
|
|
|
|
type QPluginLoader struct {
|
|
QObject
|
|
}
|
|
|
|
type QPluginLoader_ITF interface {
|
|
QObject_ITF
|
|
QPluginLoader_PTR() *QPluginLoader
|
|
}
|
|
|
|
func (p *QPluginLoader) QPluginLoader_PTR() *QPluginLoader {
|
|
return p
|
|
}
|
|
|
|
func (p *QPluginLoader) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QPluginLoader) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQPluginLoader(ptr QPluginLoader_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPluginLoader_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPluginLoaderFromPointer(ptr unsafe.Pointer) *QPluginLoader {
|
|
var n = new(QPluginLoader)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQPluginLoaderFromPointer(ptr unsafe.Pointer) *QPluginLoader {
|
|
var n = NewQPluginLoaderFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QPluginLoader_") {
|
|
n.SetObjectName("QPluginLoader_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QPluginLoader) FileName() string {
|
|
defer qt.Recovering("QPluginLoader::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QPluginLoader_FileName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QPluginLoader) LoadHints() QLibrary__LoadHint {
|
|
defer qt.Recovering("QPluginLoader::loadHints")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QLibrary__LoadHint(C.QPluginLoader_LoadHints(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPluginLoader) SetFileName(fileName string) {
|
|
defer qt.Recovering("QPluginLoader::setFileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_SetFileName(ptr.Pointer(), C.CString(fileName))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) SetLoadHints(loadHints QLibrary__LoadHint) {
|
|
defer qt.Recovering("QPluginLoader::setLoadHints")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_SetLoadHints(ptr.Pointer(), C.int(loadHints))
|
|
}
|
|
}
|
|
|
|
func NewQPluginLoader(parent QObject_ITF) *QPluginLoader {
|
|
defer qt.Recovering("QPluginLoader::QPluginLoader")
|
|
|
|
return newQPluginLoaderFromPointer(C.QPluginLoader_NewQPluginLoader(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQPluginLoader2(fileName string, parent QObject_ITF) *QPluginLoader {
|
|
defer qt.Recovering("QPluginLoader::QPluginLoader")
|
|
|
|
return newQPluginLoaderFromPointer(C.QPluginLoader_NewQPluginLoader2(C.CString(fileName), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ErrorString() string {
|
|
defer qt.Recovering("QPluginLoader::errorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QPluginLoader_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QPluginLoader) Instance() *QObject {
|
|
defer qt.Recovering("QPluginLoader::instance")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QPluginLoader_Instance(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPluginLoader) IsLoaded() bool {
|
|
defer qt.Recovering("QPluginLoader::isLoaded")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPluginLoader_IsLoaded(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QPluginLoader) Load() bool {
|
|
defer qt.Recovering("QPluginLoader::load")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPluginLoader_Load(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QPluginLoader) MetaData() *QJsonObject {
|
|
defer qt.Recovering("QPluginLoader::metaData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonObjectFromPointer(C.QPluginLoader_MetaData(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPluginLoader) Unload() bool {
|
|
defer qt.Recovering("QPluginLoader::unload")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPluginLoader_Unload(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DestroyQPluginLoader() {
|
|
defer qt.Recovering("QPluginLoader::~QPluginLoader")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_DestroyQPluginLoader(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQPluginLoader_TimerEvent
|
|
func callbackQPluginLoader_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPluginLoader::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQPluginLoaderFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QPluginLoader::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QPluginLoader::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QPluginLoader::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QPluginLoader::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQPluginLoader_ChildEvent
|
|
func callbackQPluginLoader_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPluginLoader::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQPluginLoaderFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QPluginLoader::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QPluginLoader::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QPluginLoader::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QPluginLoader::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQPluginLoader_ConnectNotify
|
|
func callbackQPluginLoader_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPluginLoader::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQPluginLoaderFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QPluginLoader::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QPluginLoader::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QPluginLoader::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QPluginLoader::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQPluginLoader_CustomEvent
|
|
func callbackQPluginLoader_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPluginLoader::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQPluginLoaderFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QPluginLoader::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QPluginLoader::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QPluginLoader::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QPluginLoader::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQPluginLoader_DeleteLater
|
|
func callbackQPluginLoader_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QPluginLoader::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQPluginLoaderFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QPluginLoader::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QPluginLoader::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DeleteLater() {
|
|
defer qt.Recovering("QPluginLoader::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DeleteLaterDefault() {
|
|
defer qt.Recovering("QPluginLoader::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQPluginLoader_DisconnectNotify
|
|
func callbackQPluginLoader_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPluginLoader::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQPluginLoaderFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QPluginLoader::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QPluginLoader::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QPluginLoader::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QPluginLoader::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPluginLoader_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQPluginLoader_Event
|
|
func callbackQPluginLoader_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QPluginLoader::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQPluginLoaderFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QPluginLoader::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QPluginLoader::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QPluginLoader::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPluginLoader_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QPluginLoader) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QPluginLoader::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPluginLoader_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQPluginLoader_EventFilter
|
|
func callbackQPluginLoader_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QPluginLoader::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQPluginLoaderFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QPluginLoader::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QPluginLoader::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QPluginLoader::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPluginLoader_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QPluginLoader) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QPluginLoader::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPluginLoader_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQPluginLoader_MetaObject
|
|
func callbackQPluginLoader_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QPluginLoader::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQPluginLoaderFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QPluginLoader) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QPluginLoader::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QPluginLoader::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPluginLoader) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QPluginLoader::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QPluginLoader_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPluginLoader) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QPluginLoader::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QPluginLoader_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QPoint struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QPoint_ITF interface {
|
|
QPoint_PTR() *QPoint
|
|
}
|
|
|
|
func (p *QPoint) QPoint_PTR() *QPoint {
|
|
return p
|
|
}
|
|
|
|
func (p *QPoint) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QPoint) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQPoint(ptr QPoint_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPoint_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPointFromPointer(ptr unsafe.Pointer) *QPoint {
|
|
var n = new(QPoint)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQPointFromPointer(ptr unsafe.Pointer) *QPoint {
|
|
var n = NewQPointFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQPoint() *QPoint {
|
|
defer qt.Recovering("QPoint::QPoint")
|
|
|
|
return newQPointFromPointer(C.QPoint_NewQPoint())
|
|
}
|
|
|
|
func NewQPoint2(xpos int, ypos int) *QPoint {
|
|
defer qt.Recovering("QPoint::QPoint")
|
|
|
|
return newQPointFromPointer(C.QPoint_NewQPoint2(C.int(xpos), C.int(ypos)))
|
|
}
|
|
|
|
func QPoint_DotProduct(p1 QPoint_ITF, p2 QPoint_ITF) int {
|
|
defer qt.Recovering("QPoint::dotProduct")
|
|
|
|
return int(C.QPoint_QPoint_DotProduct(PointerFromQPoint(p1), PointerFromQPoint(p2)))
|
|
}
|
|
|
|
func (ptr *QPoint) DotProduct(p1 QPoint_ITF, p2 QPoint_ITF) int {
|
|
defer qt.Recovering("QPoint::dotProduct")
|
|
|
|
return int(C.QPoint_QPoint_DotProduct(PointerFromQPoint(p1), PointerFromQPoint(p2)))
|
|
}
|
|
|
|
func (ptr *QPoint) IsNull() bool {
|
|
defer qt.Recovering("QPoint::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPoint_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QPoint) ManhattanLength() int {
|
|
defer qt.Recovering("QPoint::manhattanLength")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QPoint_ManhattanLength(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPoint) Rx() int {
|
|
defer qt.Recovering("QPoint::rx")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QPoint_Rx(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPoint) Ry() int {
|
|
defer qt.Recovering("QPoint::ry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QPoint_Ry(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPoint) SetX(x int) {
|
|
defer qt.Recovering("QPoint::setX")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPoint_SetX(ptr.Pointer(), C.int(x))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPoint) SetY(y int) {
|
|
defer qt.Recovering("QPoint::setY")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPoint_SetY(ptr.Pointer(), C.int(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPoint) X() int {
|
|
defer qt.Recovering("QPoint::x")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QPoint_X(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPoint) Y() int {
|
|
defer qt.Recovering("QPoint::y")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QPoint_Y(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QPointF struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QPointF_ITF interface {
|
|
QPointF_PTR() *QPointF
|
|
}
|
|
|
|
func (p *QPointF) QPointF_PTR() *QPointF {
|
|
return p
|
|
}
|
|
|
|
func (p *QPointF) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QPointF) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQPointF(ptr QPointF_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPointF_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPointFFromPointer(ptr unsafe.Pointer) *QPointF {
|
|
var n = new(QPointF)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQPointFFromPointer(ptr unsafe.Pointer) *QPointF {
|
|
var n = NewQPointFFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQPointF() *QPointF {
|
|
defer qt.Recovering("QPointF::QPointF")
|
|
|
|
return newQPointFFromPointer(C.QPointF_NewQPointF())
|
|
}
|
|
|
|
func NewQPointF2(point QPoint_ITF) *QPointF {
|
|
defer qt.Recovering("QPointF::QPointF")
|
|
|
|
return newQPointFFromPointer(C.QPointF_NewQPointF2(PointerFromQPoint(point)))
|
|
}
|
|
|
|
func NewQPointF3(xpos float64, ypos float64) *QPointF {
|
|
defer qt.Recovering("QPointF::QPointF")
|
|
|
|
return newQPointFFromPointer(C.QPointF_NewQPointF3(C.double(xpos), C.double(ypos)))
|
|
}
|
|
|
|
func QPointF_DotProduct(p1 QPointF_ITF, p2 QPointF_ITF) float64 {
|
|
defer qt.Recovering("QPointF::dotProduct")
|
|
|
|
return float64(C.QPointF_QPointF_DotProduct(PointerFromQPointF(p1), PointerFromQPointF(p2)))
|
|
}
|
|
|
|
func (ptr *QPointF) DotProduct(p1 QPointF_ITF, p2 QPointF_ITF) float64 {
|
|
defer qt.Recovering("QPointF::dotProduct")
|
|
|
|
return float64(C.QPointF_QPointF_DotProduct(PointerFromQPointF(p1), PointerFromQPointF(p2)))
|
|
}
|
|
|
|
func (ptr *QPointF) IsNull() bool {
|
|
defer qt.Recovering("QPointF::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPointF_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QPointF) ManhattanLength() float64 {
|
|
defer qt.Recovering("QPointF::manhattanLength")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QPointF_ManhattanLength(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPointF) Rx() float64 {
|
|
defer qt.Recovering("QPointF::rx")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QPointF_Rx(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPointF) Ry() float64 {
|
|
defer qt.Recovering("QPointF::ry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QPointF_Ry(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPointF) SetX(x float64) {
|
|
defer qt.Recovering("QPointF::setX")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPointF_SetX(ptr.Pointer(), C.double(x))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPointF) SetY(y float64) {
|
|
defer qt.Recovering("QPointF::setY")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPointF_SetY(ptr.Pointer(), C.double(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPointF) ToPoint() *QPoint {
|
|
defer qt.Recovering("QPointF::toPoint")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFromPointer(C.QPointF_ToPoint(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPointF) X() float64 {
|
|
defer qt.Recovering("QPointF::x")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QPointF_X(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPointF) Y() float64 {
|
|
defer qt.Recovering("QPointF::y")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QPointF_Y(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QPointer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QPointer_ITF interface {
|
|
QPointer_PTR() *QPointer
|
|
}
|
|
|
|
func (p *QPointer) QPointer_PTR() *QPointer {
|
|
return p
|
|
}
|
|
|
|
func (p *QPointer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QPointer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQPointer(ptr QPointer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPointer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPointerFromPointer(ptr unsafe.Pointer) *QPointer {
|
|
var n = new(QPointer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQPointerFromPointer(ptr unsafe.Pointer) *QPointer {
|
|
var n = NewQPointerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QProcess::ExitStatus
|
|
type QProcess__ExitStatus int64
|
|
|
|
const (
|
|
QProcess__NormalExit = QProcess__ExitStatus(0)
|
|
QProcess__CrashExit = QProcess__ExitStatus(1)
|
|
)
|
|
|
|
//QProcess::InputChannelMode
|
|
type QProcess__InputChannelMode int64
|
|
|
|
const (
|
|
QProcess__ManagedInputChannel = QProcess__InputChannelMode(0)
|
|
QProcess__ForwardedInputChannel = QProcess__InputChannelMode(1)
|
|
)
|
|
|
|
//QProcess::ProcessChannel
|
|
type QProcess__ProcessChannel int64
|
|
|
|
const (
|
|
QProcess__StandardOutput = QProcess__ProcessChannel(0)
|
|
QProcess__StandardError = QProcess__ProcessChannel(1)
|
|
)
|
|
|
|
//QProcess::ProcessChannelMode
|
|
type QProcess__ProcessChannelMode int64
|
|
|
|
const (
|
|
QProcess__SeparateChannels = QProcess__ProcessChannelMode(0)
|
|
QProcess__MergedChannels = QProcess__ProcessChannelMode(1)
|
|
QProcess__ForwardedChannels = QProcess__ProcessChannelMode(2)
|
|
QProcess__ForwardedOutputChannel = QProcess__ProcessChannelMode(3)
|
|
QProcess__ForwardedErrorChannel = QProcess__ProcessChannelMode(4)
|
|
)
|
|
|
|
//QProcess::ProcessError
|
|
type QProcess__ProcessError int64
|
|
|
|
const (
|
|
QProcess__FailedToStart = QProcess__ProcessError(0)
|
|
QProcess__Crashed = QProcess__ProcessError(1)
|
|
QProcess__Timedout = QProcess__ProcessError(2)
|
|
QProcess__ReadError = QProcess__ProcessError(3)
|
|
QProcess__WriteError = QProcess__ProcessError(4)
|
|
QProcess__UnknownError = QProcess__ProcessError(5)
|
|
)
|
|
|
|
//QProcess::ProcessState
|
|
type QProcess__ProcessState int64
|
|
|
|
const (
|
|
QProcess__NotRunning = QProcess__ProcessState(0)
|
|
QProcess__Starting = QProcess__ProcessState(1)
|
|
QProcess__Running = QProcess__ProcessState(2)
|
|
)
|
|
|
|
type QProcess struct {
|
|
QIODevice
|
|
}
|
|
|
|
type QProcess_ITF interface {
|
|
QIODevice_ITF
|
|
QProcess_PTR() *QProcess
|
|
}
|
|
|
|
func (p *QProcess) QProcess_PTR() *QProcess {
|
|
return p
|
|
}
|
|
|
|
func (p *QProcess) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QIODevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QProcess) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QIODevice_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQProcess(ptr QProcess_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QProcess_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQProcessFromPointer(ptr unsafe.Pointer) *QProcess {
|
|
var n = new(QProcess)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQProcessFromPointer(ptr unsafe.Pointer) *QProcess {
|
|
var n = NewQProcessFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QProcessEnvironment struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QProcessEnvironment_ITF interface {
|
|
QProcessEnvironment_PTR() *QProcessEnvironment
|
|
}
|
|
|
|
func (p *QProcessEnvironment) QProcessEnvironment_PTR() *QProcessEnvironment {
|
|
return p
|
|
}
|
|
|
|
func (p *QProcessEnvironment) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QProcessEnvironment) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQProcessEnvironment(ptr QProcessEnvironment_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QProcessEnvironment_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQProcessEnvironmentFromPointer(ptr unsafe.Pointer) *QProcessEnvironment {
|
|
var n = new(QProcessEnvironment)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQProcessEnvironmentFromPointer(ptr unsafe.Pointer) *QProcessEnvironment {
|
|
var n = NewQProcessEnvironmentFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QPropertyAnimation struct {
|
|
QVariantAnimation
|
|
}
|
|
|
|
type QPropertyAnimation_ITF interface {
|
|
QVariantAnimation_ITF
|
|
QPropertyAnimation_PTR() *QPropertyAnimation
|
|
}
|
|
|
|
func (p *QPropertyAnimation) QPropertyAnimation_PTR() *QPropertyAnimation {
|
|
return p
|
|
}
|
|
|
|
func (p *QPropertyAnimation) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QVariantAnimation_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QPropertyAnimation) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QVariantAnimation_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQPropertyAnimation(ptr QPropertyAnimation_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPropertyAnimation_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPropertyAnimationFromPointer(ptr unsafe.Pointer) *QPropertyAnimation {
|
|
var n = new(QPropertyAnimation)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQPropertyAnimationFromPointer(ptr unsafe.Pointer) *QPropertyAnimation {
|
|
var n = NewQPropertyAnimationFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QPropertyAnimation_") {
|
|
n.SetObjectName("QPropertyAnimation_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) PropertyName() string {
|
|
defer qt.Recovering("QPropertyAnimation::propertyName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QPropertyAnimation_PropertyName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) SetPropertyName(propertyName string) {
|
|
defer qt.Recovering("QPropertyAnimation::setPropertyName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_SetPropertyName(ptr.Pointer(), C.CString(propertyName))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) SetTargetObject(target QObject_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::setTargetObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_SetTargetObject(ptr.Pointer(), PointerFromQObject(target))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) TargetObject() *QObject {
|
|
defer qt.Recovering("QPropertyAnimation::targetObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QPropertyAnimation_TargetObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPropertyAnimation(parent QObject_ITF) *QPropertyAnimation {
|
|
defer qt.Recovering("QPropertyAnimation::QPropertyAnimation")
|
|
|
|
return newQPropertyAnimationFromPointer(C.QPropertyAnimation_NewQPropertyAnimation(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQPropertyAnimation2(target QObject_ITF, propertyName string, parent QObject_ITF) *QPropertyAnimation {
|
|
defer qt.Recovering("QPropertyAnimation::QPropertyAnimation")
|
|
|
|
return newQPropertyAnimationFromPointer(C.QPropertyAnimation_NewQPropertyAnimation2(PointerFromQObject(target), C.CString(propertyName), PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_Event
|
|
func callbackQPropertyAnimation_Event(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QPropertyAnimation::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQPropertyAnimationFromPointer(ptr).EventDefault(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectEvent(f func(event *QEvent) bool) {
|
|
defer qt.Recovering("connect QPropertyAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) Event(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QPropertyAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPropertyAnimation_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) EventDefault(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QPropertyAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPropertyAnimation_EventDefault(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_UpdateCurrentValue
|
|
func callbackQPropertyAnimation_UpdateCurrentValue(ptr unsafe.Pointer, ptrName *C.char, value unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPropertyAnimation::updateCurrentValue")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentValue"); signal != nil {
|
|
signal.(func(*QVariant))(NewQVariantFromPointer(value))
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).UpdateCurrentValueDefault(NewQVariantFromPointer(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectUpdateCurrentValue(f func(value *QVariant)) {
|
|
defer qt.Recovering("connect QPropertyAnimation::updateCurrentValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateCurrentValue", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectUpdateCurrentValue() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::updateCurrentValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateCurrentValue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) UpdateCurrentValue(value QVariant_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::updateCurrentValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_UpdateCurrentValue(ptr.Pointer(), PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) UpdateCurrentValueDefault(value QVariant_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::updateCurrentValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_UpdateCurrentValueDefault(ptr.Pointer(), PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_UpdateState
|
|
func callbackQPropertyAnimation_UpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
|
|
defer qt.Recovering("callback QPropertyAnimation::updateState")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
|
|
signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
|
|
defer qt.Recovering("connect QPropertyAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectUpdateState() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateState")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QPropertyAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QPropertyAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DestroyQPropertyAnimation() {
|
|
defer qt.Recovering("QPropertyAnimation::~QPropertyAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QPropertyAnimation_DestroyQPropertyAnimation(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_Duration
|
|
func callbackQPropertyAnimation_Duration(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QPropertyAnimation::duration")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "duration"); signal != nil {
|
|
return C.int(signal.(func() int)())
|
|
}
|
|
|
|
return C.int(NewQPropertyAnimationFromPointer(ptr).DurationDefault())
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectDuration(f func() int) {
|
|
defer qt.Recovering("connect QPropertyAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "duration", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectDuration() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) Duration() int {
|
|
defer qt.Recovering("QPropertyAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QPropertyAnimation_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DurationDefault() int {
|
|
defer qt.Recovering("QPropertyAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QPropertyAnimation_DurationDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_Interpolated
|
|
func callbackQPropertyAnimation_Interpolated(ptr unsafe.Pointer, ptrName *C.char, from unsafe.Pointer, to unsafe.Pointer, progress C.double) unsafe.Pointer {
|
|
defer qt.Recovering("callback QPropertyAnimation::interpolated")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "interpolated"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(*QVariant, *QVariant, float64) *QVariant)(NewQVariantFromPointer(from), NewQVariantFromPointer(to), float64(progress)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQPropertyAnimationFromPointer(ptr).InterpolatedDefault(NewQVariantFromPointer(from), NewQVariantFromPointer(to), float64(progress)))
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectInterpolated(f func(from *QVariant, to *QVariant, progress float64) *QVariant) {
|
|
defer qt.Recovering("connect QPropertyAnimation::interpolated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "interpolated", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectInterpolated() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::interpolated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "interpolated")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) Interpolated(from QVariant_ITF, to QVariant_ITF, progress float64) *QVariant {
|
|
defer qt.Recovering("QPropertyAnimation::interpolated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QPropertyAnimation_Interpolated(ptr.Pointer(), PointerFromQVariant(from), PointerFromQVariant(to), C.double(progress)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) InterpolatedDefault(from QVariant_ITF, to QVariant_ITF, progress float64) *QVariant {
|
|
defer qt.Recovering("QPropertyAnimation::interpolated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QPropertyAnimation_InterpolatedDefault(ptr.Pointer(), PointerFromQVariant(from), PointerFromQVariant(to), C.double(progress)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_UpdateCurrentTime
|
|
func callbackQPropertyAnimation_UpdateCurrentTime(ptr unsafe.Pointer, ptrName *C.char, vin C.int) {
|
|
defer qt.Recovering("callback QPropertyAnimation::updateCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(vin))
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).UpdateCurrentTimeDefault(int(vin))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectUpdateCurrentTime(f func(vin int)) {
|
|
defer qt.Recovering("connect QPropertyAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectUpdateCurrentTime() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) UpdateCurrentTime(vin int) {
|
|
defer qt.Recovering("QPropertyAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_UpdateCurrentTime(ptr.Pointer(), C.int(vin))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) UpdateCurrentTimeDefault(vin int) {
|
|
defer qt.Recovering("QPropertyAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(vin))
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_SetCurrentTime
|
|
func callbackQPropertyAnimation_SetCurrentTime(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) {
|
|
defer qt.Recovering("callback QPropertyAnimation::setCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(msecs))
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).SetCurrentTimeDefault(int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectSetCurrentTime(f func(msecs int)) {
|
|
defer qt.Recovering("connect QPropertyAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectSetCurrentTime() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) SetCurrentTime(msecs int) {
|
|
defer qt.Recovering("QPropertyAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_SetCurrentTime(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) SetCurrentTimeDefault(msecs int) {
|
|
defer qt.Recovering("QPropertyAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_SetCurrentTimeDefault(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_Pause
|
|
func callbackQPropertyAnimation_Pause(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QPropertyAnimation::pause")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pause"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).PauseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectPause(f func()) {
|
|
defer qt.Recovering("connect QPropertyAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pause", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectPause() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pause")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) Pause() {
|
|
defer qt.Recovering("QPropertyAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_Pause(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) PauseDefault() {
|
|
defer qt.Recovering("QPropertyAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_PauseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_Resume
|
|
func callbackQPropertyAnimation_Resume(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QPropertyAnimation::resume")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resume"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).ResumeDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectResume(f func()) {
|
|
defer qt.Recovering("connect QPropertyAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resume", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectResume() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) Resume() {
|
|
defer qt.Recovering("QPropertyAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_Resume(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ResumeDefault() {
|
|
defer qt.Recovering("QPropertyAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_ResumeDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_SetPaused
|
|
func callbackQPropertyAnimation_SetPaused(ptr unsafe.Pointer, ptrName *C.char, paused C.int) {
|
|
defer qt.Recovering("callback QPropertyAnimation::setPaused")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setPaused"); signal != nil {
|
|
signal.(func(bool))(int(paused) != 0)
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).SetPausedDefault(int(paused) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectSetPaused(f func(paused bool)) {
|
|
defer qt.Recovering("connect QPropertyAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setPaused", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectSetPaused() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setPaused")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) SetPaused(paused bool) {
|
|
defer qt.Recovering("QPropertyAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_SetPaused(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) SetPausedDefault(paused bool) {
|
|
defer qt.Recovering("QPropertyAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_SetPausedDefault(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_Start
|
|
func callbackQPropertyAnimation_Start(ptr unsafe.Pointer, ptrName *C.char, policy C.int) {
|
|
defer qt.Recovering("callback QPropertyAnimation::start")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "start"); signal != nil {
|
|
signal.(func(QAbstractAnimation__DeletionPolicy))(QAbstractAnimation__DeletionPolicy(policy))
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).StartDefault(QAbstractAnimation__DeletionPolicy(policy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectStart(f func(policy QAbstractAnimation__DeletionPolicy)) {
|
|
defer qt.Recovering("connect QPropertyAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "start", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectStart() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) Start(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QPropertyAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_Start(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) StartDefault(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QPropertyAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_StartDefault(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_Stop
|
|
func callbackQPropertyAnimation_Stop(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QPropertyAnimation::stop")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectStop(f func()) {
|
|
defer qt.Recovering("connect QPropertyAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "stop", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectStop() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) Stop() {
|
|
defer qt.Recovering("QPropertyAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) StopDefault() {
|
|
defer qt.Recovering("QPropertyAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_UpdateDirection
|
|
func callbackQPropertyAnimation_UpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
|
|
defer qt.Recovering("callback QPropertyAnimation::updateDirection")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
|
|
signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
|
|
defer qt.Recovering("connect QPropertyAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectUpdateDirection() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateDirection")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) UpdateDirection(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QPropertyAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_UpdateDirection(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QPropertyAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_TimerEvent
|
|
func callbackQPropertyAnimation_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPropertyAnimation::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QPropertyAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_ChildEvent
|
|
func callbackQPropertyAnimation_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPropertyAnimation::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QPropertyAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_ConnectNotify
|
|
func callbackQPropertyAnimation_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPropertyAnimation::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QPropertyAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_CustomEvent
|
|
func callbackQPropertyAnimation_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPropertyAnimation::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QPropertyAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_DeleteLater
|
|
func callbackQPropertyAnimation_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QPropertyAnimation::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QPropertyAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DeleteLater() {
|
|
defer qt.Recovering("QPropertyAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QPropertyAnimation_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DeleteLaterDefault() {
|
|
defer qt.Recovering("QPropertyAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QPropertyAnimation_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_DisconnectNotify
|
|
func callbackQPropertyAnimation_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QPropertyAnimation::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQPropertyAnimationFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QPropertyAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QPropertyAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QPropertyAnimation_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_EventFilter
|
|
func callbackQPropertyAnimation_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QPropertyAnimation::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQPropertyAnimationFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QPropertyAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QPropertyAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPropertyAnimation_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QPropertyAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QPropertyAnimation_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQPropertyAnimation_MetaObject
|
|
func callbackQPropertyAnimation_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QPropertyAnimation::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQPropertyAnimationFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QPropertyAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QPropertyAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QPropertyAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QPropertyAnimation_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPropertyAnimation) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QPropertyAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QPropertyAnimation_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QQueue struct {
|
|
QList
|
|
}
|
|
|
|
type QQueue_ITF interface {
|
|
QList_ITF
|
|
QQueue_PTR() *QQueue
|
|
}
|
|
|
|
func (p *QQueue) QQueue_PTR() *QQueue {
|
|
return p
|
|
}
|
|
|
|
func (p *QQueue) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QList_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QQueue) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QList_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQQueue(ptr QQueue_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QQueue_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQQueueFromPointer(ptr unsafe.Pointer) *QQueue {
|
|
var n = new(QQueue)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQQueueFromPointer(ptr unsafe.Pointer) *QQueue {
|
|
var n = NewQQueueFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QReadLocker struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QReadLocker_ITF interface {
|
|
QReadLocker_PTR() *QReadLocker
|
|
}
|
|
|
|
func (p *QReadLocker) QReadLocker_PTR() *QReadLocker {
|
|
return p
|
|
}
|
|
|
|
func (p *QReadLocker) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QReadLocker) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQReadLocker(ptr QReadLocker_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QReadLocker_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQReadLockerFromPointer(ptr unsafe.Pointer) *QReadLocker {
|
|
var n = new(QReadLocker)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQReadLockerFromPointer(ptr unsafe.Pointer) *QReadLocker {
|
|
var n = NewQReadLockerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQReadLocker(lock QReadWriteLock_ITF) *QReadLocker {
|
|
defer qt.Recovering("QReadLocker::QReadLocker")
|
|
|
|
return newQReadLockerFromPointer(C.QReadLocker_NewQReadLocker(PointerFromQReadWriteLock(lock)))
|
|
}
|
|
|
|
func (ptr *QReadLocker) ReadWriteLock() *QReadWriteLock {
|
|
defer qt.Recovering("QReadLocker::readWriteLock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQReadWriteLockFromPointer(C.QReadLocker_ReadWriteLock(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QReadLocker) Relock() {
|
|
defer qt.Recovering("QReadLocker::relock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QReadLocker_Relock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QReadLocker) Unlock() {
|
|
defer qt.Recovering("QReadLocker::unlock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QReadLocker_Unlock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QReadLocker) DestroyQReadLocker() {
|
|
defer qt.Recovering("QReadLocker::~QReadLocker")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QReadLocker_DestroyQReadLocker(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QReadWriteLock::RecursionMode
|
|
type QReadWriteLock__RecursionMode int64
|
|
|
|
const (
|
|
QReadWriteLock__NonRecursive = QReadWriteLock__RecursionMode(0)
|
|
QReadWriteLock__Recursive = QReadWriteLock__RecursionMode(1)
|
|
)
|
|
|
|
type QReadWriteLock struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QReadWriteLock_ITF interface {
|
|
QReadWriteLock_PTR() *QReadWriteLock
|
|
}
|
|
|
|
func (p *QReadWriteLock) QReadWriteLock_PTR() *QReadWriteLock {
|
|
return p
|
|
}
|
|
|
|
func (p *QReadWriteLock) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QReadWriteLock) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQReadWriteLock(ptr QReadWriteLock_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QReadWriteLock_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQReadWriteLockFromPointer(ptr unsafe.Pointer) *QReadWriteLock {
|
|
var n = new(QReadWriteLock)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQReadWriteLockFromPointer(ptr unsafe.Pointer) *QReadWriteLock {
|
|
var n = NewQReadWriteLockFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQReadWriteLock(recursionMode QReadWriteLock__RecursionMode) *QReadWriteLock {
|
|
defer qt.Recovering("QReadWriteLock::QReadWriteLock")
|
|
|
|
return newQReadWriteLockFromPointer(C.QReadWriteLock_NewQReadWriteLock(C.int(recursionMode)))
|
|
}
|
|
|
|
func (ptr *QReadWriteLock) LockForRead() {
|
|
defer qt.Recovering("QReadWriteLock::lockForRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QReadWriteLock_LockForRead(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QReadWriteLock) LockForWrite() {
|
|
defer qt.Recovering("QReadWriteLock::lockForWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QReadWriteLock_LockForWrite(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QReadWriteLock) TryLockForRead() bool {
|
|
defer qt.Recovering("QReadWriteLock::tryLockForRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QReadWriteLock_TryLockForRead(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QReadWriteLock) TryLockForRead2(timeout int) bool {
|
|
defer qt.Recovering("QReadWriteLock::tryLockForRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QReadWriteLock_TryLockForRead2(ptr.Pointer(), C.int(timeout)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QReadWriteLock) TryLockForWrite() bool {
|
|
defer qt.Recovering("QReadWriteLock::tryLockForWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QReadWriteLock_TryLockForWrite(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QReadWriteLock) TryLockForWrite2(timeout int) bool {
|
|
defer qt.Recovering("QReadWriteLock::tryLockForWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QReadWriteLock_TryLockForWrite2(ptr.Pointer(), C.int(timeout)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QReadWriteLock) Unlock() {
|
|
defer qt.Recovering("QReadWriteLock::unlock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QReadWriteLock_Unlock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QReadWriteLock) DestroyQReadWriteLock() {
|
|
defer qt.Recovering("QReadWriteLock::~QReadWriteLock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QReadWriteLock_DestroyQReadWriteLock(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QRect struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QRect_ITF interface {
|
|
QRect_PTR() *QRect
|
|
}
|
|
|
|
func (p *QRect) QRect_PTR() *QRect {
|
|
return p
|
|
}
|
|
|
|
func (p *QRect) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QRect) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQRect(ptr QRect_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QRect_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQRectFromPointer(ptr unsafe.Pointer) *QRect {
|
|
var n = new(QRect)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQRectFromPointer(ptr unsafe.Pointer) *QRect {
|
|
var n = NewQRectFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QRect) Contains(point QPoint_ITF, proper bool) bool {
|
|
defer qt.Recovering("QRect::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRect_Contains(ptr.Pointer(), PointerFromQPoint(point), C.int(qt.GoBoolToInt(proper))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRect) Contains2(rectangle QRect_ITF, proper bool) bool {
|
|
defer qt.Recovering("QRect::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRect_Contains2(ptr.Pointer(), PointerFromQRect(rectangle), C.int(qt.GoBoolToInt(proper))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRect) Intersects(rectangle QRect_ITF) bool {
|
|
defer qt.Recovering("QRect::intersects")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRect_Intersects(ptr.Pointer(), PointerFromQRect(rectangle)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func NewQRect() *QRect {
|
|
defer qt.Recovering("QRect::QRect")
|
|
|
|
return newQRectFromPointer(C.QRect_NewQRect())
|
|
}
|
|
|
|
func NewQRect2(topLeft QPoint_ITF, bottomRight QPoint_ITF) *QRect {
|
|
defer qt.Recovering("QRect::QRect")
|
|
|
|
return newQRectFromPointer(C.QRect_NewQRect2(PointerFromQPoint(topLeft), PointerFromQPoint(bottomRight)))
|
|
}
|
|
|
|
func NewQRect3(topLeft QPoint_ITF, size QSize_ITF) *QRect {
|
|
defer qt.Recovering("QRect::QRect")
|
|
|
|
return newQRectFromPointer(C.QRect_NewQRect3(PointerFromQPoint(topLeft), PointerFromQSize(size)))
|
|
}
|
|
|
|
func NewQRect4(x int, y int, width int, height int) *QRect {
|
|
defer qt.Recovering("QRect::QRect")
|
|
|
|
return newQRectFromPointer(C.QRect_NewQRect4(C.int(x), C.int(y), C.int(width), C.int(height)))
|
|
}
|
|
|
|
func (ptr *QRect) Adjust(dx1 int, dy1 int, dx2 int, dy2 int) {
|
|
defer qt.Recovering("QRect::adjust")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_Adjust(ptr.Pointer(), C.int(dx1), C.int(dy1), C.int(dx2), C.int(dy2))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) Adjusted(dx1 int, dy1 int, dx2 int, dy2 int) *QRect {
|
|
defer qt.Recovering("QRect::adjusted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFromPointer(C.QRect_Adjusted(ptr.Pointer(), C.int(dx1), C.int(dy1), C.int(dx2), C.int(dy2)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) Bottom() int {
|
|
defer qt.Recovering("QRect::bottom")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRect_Bottom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRect) BottomLeft() *QPoint {
|
|
defer qt.Recovering("QRect::bottomLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFromPointer(C.QRect_BottomLeft(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) BottomRight() *QPoint {
|
|
defer qt.Recovering("QRect::bottomRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFromPointer(C.QRect_BottomRight(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) Center() *QPoint {
|
|
defer qt.Recovering("QRect::center")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFromPointer(C.QRect_Center(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) Contains3(x int, y int) bool {
|
|
defer qt.Recovering("QRect::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRect_Contains3(ptr.Pointer(), C.int(x), C.int(y)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRect) Contains4(x int, y int, proper bool) bool {
|
|
defer qt.Recovering("QRect::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRect_Contains4(ptr.Pointer(), C.int(x), C.int(y), C.int(qt.GoBoolToInt(proper))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRect) GetCoords(x1 int, y1 int, x2 int, y2 int) {
|
|
defer qt.Recovering("QRect::getCoords")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_GetCoords(ptr.Pointer(), C.int(x1), C.int(y1), C.int(x2), C.int(y2))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) GetRect(x int, y int, width int, height int) {
|
|
defer qt.Recovering("QRect::getRect")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_GetRect(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) Height() int {
|
|
defer qt.Recovering("QRect::height")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRect_Height(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRect) Intersected(rectangle QRect_ITF) *QRect {
|
|
defer qt.Recovering("QRect::intersected")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFromPointer(C.QRect_Intersected(ptr.Pointer(), PointerFromQRect(rectangle)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) IsEmpty() bool {
|
|
defer qt.Recovering("QRect::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRect_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRect) IsNull() bool {
|
|
defer qt.Recovering("QRect::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRect_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRect) IsValid() bool {
|
|
defer qt.Recovering("QRect::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRect_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRect) Left() int {
|
|
defer qt.Recovering("QRect::left")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRect_Left(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRect) MarginsAdded(margins QMargins_ITF) *QRect {
|
|
defer qt.Recovering("QRect::marginsAdded")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFromPointer(C.QRect_MarginsAdded(ptr.Pointer(), PointerFromQMargins(margins)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) MarginsRemoved(margins QMargins_ITF) *QRect {
|
|
defer qt.Recovering("QRect::marginsRemoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFromPointer(C.QRect_MarginsRemoved(ptr.Pointer(), PointerFromQMargins(margins)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) MoveBottom(y int) {
|
|
defer qt.Recovering("QRect::moveBottom")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_MoveBottom(ptr.Pointer(), C.int(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) MoveBottomLeft(position QPoint_ITF) {
|
|
defer qt.Recovering("QRect::moveBottomLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_MoveBottomLeft(ptr.Pointer(), PointerFromQPoint(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) MoveBottomRight(position QPoint_ITF) {
|
|
defer qt.Recovering("QRect::moveBottomRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_MoveBottomRight(ptr.Pointer(), PointerFromQPoint(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) MoveCenter(position QPoint_ITF) {
|
|
defer qt.Recovering("QRect::moveCenter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_MoveCenter(ptr.Pointer(), PointerFromQPoint(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) MoveLeft(x int) {
|
|
defer qt.Recovering("QRect::moveLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_MoveLeft(ptr.Pointer(), C.int(x))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) MoveRight(x int) {
|
|
defer qt.Recovering("QRect::moveRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_MoveRight(ptr.Pointer(), C.int(x))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) MoveTo2(position QPoint_ITF) {
|
|
defer qt.Recovering("QRect::moveTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_MoveTo2(ptr.Pointer(), PointerFromQPoint(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) MoveTo(x int, y int) {
|
|
defer qt.Recovering("QRect::moveTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_MoveTo(ptr.Pointer(), C.int(x), C.int(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) MoveTop(y int) {
|
|
defer qt.Recovering("QRect::moveTop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_MoveTop(ptr.Pointer(), C.int(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) MoveTopLeft(position QPoint_ITF) {
|
|
defer qt.Recovering("QRect::moveTopLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_MoveTopLeft(ptr.Pointer(), PointerFromQPoint(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) MoveTopRight(position QPoint_ITF) {
|
|
defer qt.Recovering("QRect::moveTopRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_MoveTopRight(ptr.Pointer(), PointerFromQPoint(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) Normalized() *QRect {
|
|
defer qt.Recovering("QRect::normalized")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFromPointer(C.QRect_Normalized(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) Right() int {
|
|
defer qt.Recovering("QRect::right")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRect_Right(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRect) SetBottom(y int) {
|
|
defer qt.Recovering("QRect::setBottom")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetBottom(ptr.Pointer(), C.int(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetBottomLeft(position QPoint_ITF) {
|
|
defer qt.Recovering("QRect::setBottomLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetBottomLeft(ptr.Pointer(), PointerFromQPoint(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetBottomRight(position QPoint_ITF) {
|
|
defer qt.Recovering("QRect::setBottomRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetBottomRight(ptr.Pointer(), PointerFromQPoint(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetCoords(x1 int, y1 int, x2 int, y2 int) {
|
|
defer qt.Recovering("QRect::setCoords")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetCoords(ptr.Pointer(), C.int(x1), C.int(y1), C.int(x2), C.int(y2))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetHeight(height int) {
|
|
defer qt.Recovering("QRect::setHeight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetHeight(ptr.Pointer(), C.int(height))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetLeft(x int) {
|
|
defer qt.Recovering("QRect::setLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetLeft(ptr.Pointer(), C.int(x))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetRect(x int, y int, width int, height int) {
|
|
defer qt.Recovering("QRect::setRect")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetRect(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetRight(x int) {
|
|
defer qt.Recovering("QRect::setRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetRight(ptr.Pointer(), C.int(x))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetSize(size QSize_ITF) {
|
|
defer qt.Recovering("QRect::setSize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetSize(ptr.Pointer(), PointerFromQSize(size))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetTop(y int) {
|
|
defer qt.Recovering("QRect::setTop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetTop(ptr.Pointer(), C.int(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetTopLeft(position QPoint_ITF) {
|
|
defer qt.Recovering("QRect::setTopLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetTopLeft(ptr.Pointer(), PointerFromQPoint(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetTopRight(position QPoint_ITF) {
|
|
defer qt.Recovering("QRect::setTopRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetTopRight(ptr.Pointer(), PointerFromQPoint(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetWidth(width int) {
|
|
defer qt.Recovering("QRect::setWidth")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetWidth(ptr.Pointer(), C.int(width))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetX(x int) {
|
|
defer qt.Recovering("QRect::setX")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetX(ptr.Pointer(), C.int(x))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) SetY(y int) {
|
|
defer qt.Recovering("QRect::setY")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_SetY(ptr.Pointer(), C.int(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) Size() *QSize {
|
|
defer qt.Recovering("QRect::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QRect_Size(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) Top() int {
|
|
defer qt.Recovering("QRect::top")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRect_Top(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRect) TopLeft() *QPoint {
|
|
defer qt.Recovering("QRect::topLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFromPointer(C.QRect_TopLeft(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) TopRight() *QPoint {
|
|
defer qt.Recovering("QRect::topRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFromPointer(C.QRect_TopRight(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) Translate2(offset QPoint_ITF) {
|
|
defer qt.Recovering("QRect::translate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_Translate2(ptr.Pointer(), PointerFromQPoint(offset))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) Translate(dx int, dy int) {
|
|
defer qt.Recovering("QRect::translate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRect_Translate(ptr.Pointer(), C.int(dx), C.int(dy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRect) Translated2(offset QPoint_ITF) *QRect {
|
|
defer qt.Recovering("QRect::translated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFromPointer(C.QRect_Translated2(ptr.Pointer(), PointerFromQPoint(offset)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) Translated(dx int, dy int) *QRect {
|
|
defer qt.Recovering("QRect::translated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFromPointer(C.QRect_Translated(ptr.Pointer(), C.int(dx), C.int(dy)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) United(rectangle QRect_ITF) *QRect {
|
|
defer qt.Recovering("QRect::united")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFromPointer(C.QRect_United(ptr.Pointer(), PointerFromQRect(rectangle)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRect) Width() int {
|
|
defer qt.Recovering("QRect::width")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRect_Width(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRect) X() int {
|
|
defer qt.Recovering("QRect::x")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRect_X(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRect) Y() int {
|
|
defer qt.Recovering("QRect::y")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRect_Y(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QRectF struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QRectF_ITF interface {
|
|
QRectF_PTR() *QRectF
|
|
}
|
|
|
|
func (p *QRectF) QRectF_PTR() *QRectF {
|
|
return p
|
|
}
|
|
|
|
func (p *QRectF) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QRectF) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQRectF(ptr QRectF_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QRectF_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQRectFFromPointer(ptr unsafe.Pointer) *QRectF {
|
|
var n = new(QRectF)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQRectFFromPointer(ptr unsafe.Pointer) *QRectF {
|
|
var n = NewQRectFFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QRectF) Contains(point QPointF_ITF) bool {
|
|
defer qt.Recovering("QRectF::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRectF_Contains(ptr.Pointer(), PointerFromQPointF(point)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRectF) Contains2(rectangle QRectF_ITF) bool {
|
|
defer qt.Recovering("QRectF::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRectF_Contains2(ptr.Pointer(), PointerFromQRectF(rectangle)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRectF) Intersects(rectangle QRectF_ITF) bool {
|
|
defer qt.Recovering("QRectF::intersects")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRectF_Intersects(ptr.Pointer(), PointerFromQRectF(rectangle)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRectF) ToAlignedRect() *QRect {
|
|
defer qt.Recovering("QRectF::toAlignedRect")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFromPointer(C.QRectF_ToAlignedRect(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQRectF() *QRectF {
|
|
defer qt.Recovering("QRectF::QRectF")
|
|
|
|
return newQRectFFromPointer(C.QRectF_NewQRectF())
|
|
}
|
|
|
|
func NewQRectF3(topLeft QPointF_ITF, bottomRight QPointF_ITF) *QRectF {
|
|
defer qt.Recovering("QRectF::QRectF")
|
|
|
|
return newQRectFFromPointer(C.QRectF_NewQRectF3(PointerFromQPointF(topLeft), PointerFromQPointF(bottomRight)))
|
|
}
|
|
|
|
func NewQRectF2(topLeft QPointF_ITF, size QSizeF_ITF) *QRectF {
|
|
defer qt.Recovering("QRectF::QRectF")
|
|
|
|
return newQRectFFromPointer(C.QRectF_NewQRectF2(PointerFromQPointF(topLeft), PointerFromQSizeF(size)))
|
|
}
|
|
|
|
func NewQRectF5(rectangle QRect_ITF) *QRectF {
|
|
defer qt.Recovering("QRectF::QRectF")
|
|
|
|
return newQRectFFromPointer(C.QRectF_NewQRectF5(PointerFromQRect(rectangle)))
|
|
}
|
|
|
|
func NewQRectF4(x float64, y float64, width float64, height float64) *QRectF {
|
|
defer qt.Recovering("QRectF::QRectF")
|
|
|
|
return newQRectFFromPointer(C.QRectF_NewQRectF4(C.double(x), C.double(y), C.double(width), C.double(height)))
|
|
}
|
|
|
|
func (ptr *QRectF) Adjust(dx1 float64, dy1 float64, dx2 float64, dy2 float64) {
|
|
defer qt.Recovering("QRectF::adjust")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_Adjust(ptr.Pointer(), C.double(dx1), C.double(dy1), C.double(dx2), C.double(dy2))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) Adjusted(dx1 float64, dy1 float64, dx2 float64, dy2 float64) *QRectF {
|
|
defer qt.Recovering("QRectF::adjusted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFFromPointer(C.QRectF_Adjusted(ptr.Pointer(), C.double(dx1), C.double(dy1), C.double(dx2), C.double(dy2)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) Bottom() float64 {
|
|
defer qt.Recovering("QRectF::bottom")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QRectF_Bottom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRectF) BottomLeft() *QPointF {
|
|
defer qt.Recovering("QRectF::bottomLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFFromPointer(C.QRectF_BottomLeft(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) BottomRight() *QPointF {
|
|
defer qt.Recovering("QRectF::bottomRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFFromPointer(C.QRectF_BottomRight(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) Center() *QPointF {
|
|
defer qt.Recovering("QRectF::center")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFFromPointer(C.QRectF_Center(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) Contains3(x float64, y float64) bool {
|
|
defer qt.Recovering("QRectF::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRectF_Contains3(ptr.Pointer(), C.double(x), C.double(y)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRectF) Height() float64 {
|
|
defer qt.Recovering("QRectF::height")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QRectF_Height(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRectF) Intersected(rectangle QRectF_ITF) *QRectF {
|
|
defer qt.Recovering("QRectF::intersected")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFFromPointer(C.QRectF_Intersected(ptr.Pointer(), PointerFromQRectF(rectangle)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) IsEmpty() bool {
|
|
defer qt.Recovering("QRectF::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRectF_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRectF) IsNull() bool {
|
|
defer qt.Recovering("QRectF::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRectF_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRectF) IsValid() bool {
|
|
defer qt.Recovering("QRectF::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRectF_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRectF) Left() float64 {
|
|
defer qt.Recovering("QRectF::left")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QRectF_Left(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRectF) MarginsAdded(margins QMarginsF_ITF) *QRectF {
|
|
defer qt.Recovering("QRectF::marginsAdded")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFFromPointer(C.QRectF_MarginsAdded(ptr.Pointer(), PointerFromQMarginsF(margins)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) MarginsRemoved(margins QMarginsF_ITF) *QRectF {
|
|
defer qt.Recovering("QRectF::marginsRemoved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFFromPointer(C.QRectF_MarginsRemoved(ptr.Pointer(), PointerFromQMarginsF(margins)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) MoveBottom(y float64) {
|
|
defer qt.Recovering("QRectF::moveBottom")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_MoveBottom(ptr.Pointer(), C.double(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) MoveBottomLeft(position QPointF_ITF) {
|
|
defer qt.Recovering("QRectF::moveBottomLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_MoveBottomLeft(ptr.Pointer(), PointerFromQPointF(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) MoveBottomRight(position QPointF_ITF) {
|
|
defer qt.Recovering("QRectF::moveBottomRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_MoveBottomRight(ptr.Pointer(), PointerFromQPointF(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) MoveCenter(position QPointF_ITF) {
|
|
defer qt.Recovering("QRectF::moveCenter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_MoveCenter(ptr.Pointer(), PointerFromQPointF(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) MoveLeft(x float64) {
|
|
defer qt.Recovering("QRectF::moveLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_MoveLeft(ptr.Pointer(), C.double(x))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) MoveRight(x float64) {
|
|
defer qt.Recovering("QRectF::moveRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_MoveRight(ptr.Pointer(), C.double(x))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) MoveTo2(position QPointF_ITF) {
|
|
defer qt.Recovering("QRectF::moveTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_MoveTo2(ptr.Pointer(), PointerFromQPointF(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) MoveTo(x float64, y float64) {
|
|
defer qt.Recovering("QRectF::moveTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_MoveTo(ptr.Pointer(), C.double(x), C.double(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) MoveTop(y float64) {
|
|
defer qt.Recovering("QRectF::moveTop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_MoveTop(ptr.Pointer(), C.double(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) MoveTopLeft(position QPointF_ITF) {
|
|
defer qt.Recovering("QRectF::moveTopLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_MoveTopLeft(ptr.Pointer(), PointerFromQPointF(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) MoveTopRight(position QPointF_ITF) {
|
|
defer qt.Recovering("QRectF::moveTopRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_MoveTopRight(ptr.Pointer(), PointerFromQPointF(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) Normalized() *QRectF {
|
|
defer qt.Recovering("QRectF::normalized")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFFromPointer(C.QRectF_Normalized(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) Right() float64 {
|
|
defer qt.Recovering("QRectF::right")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QRectF_Right(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRectF) SetBottom(y float64) {
|
|
defer qt.Recovering("QRectF::setBottom")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetBottom(ptr.Pointer(), C.double(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetBottomLeft(position QPointF_ITF) {
|
|
defer qt.Recovering("QRectF::setBottomLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetBottomLeft(ptr.Pointer(), PointerFromQPointF(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetBottomRight(position QPointF_ITF) {
|
|
defer qt.Recovering("QRectF::setBottomRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetBottomRight(ptr.Pointer(), PointerFromQPointF(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetCoords(x1 float64, y1 float64, x2 float64, y2 float64) {
|
|
defer qt.Recovering("QRectF::setCoords")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetCoords(ptr.Pointer(), C.double(x1), C.double(y1), C.double(x2), C.double(y2))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetHeight(height float64) {
|
|
defer qt.Recovering("QRectF::setHeight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetHeight(ptr.Pointer(), C.double(height))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetLeft(x float64) {
|
|
defer qt.Recovering("QRectF::setLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetLeft(ptr.Pointer(), C.double(x))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetRect(x float64, y float64, width float64, height float64) {
|
|
defer qt.Recovering("QRectF::setRect")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetRect(ptr.Pointer(), C.double(x), C.double(y), C.double(width), C.double(height))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetRight(x float64) {
|
|
defer qt.Recovering("QRectF::setRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetRight(ptr.Pointer(), C.double(x))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetSize(size QSizeF_ITF) {
|
|
defer qt.Recovering("QRectF::setSize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetSize(ptr.Pointer(), PointerFromQSizeF(size))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetTop(y float64) {
|
|
defer qt.Recovering("QRectF::setTop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetTop(ptr.Pointer(), C.double(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetTopLeft(position QPointF_ITF) {
|
|
defer qt.Recovering("QRectF::setTopLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetTopLeft(ptr.Pointer(), PointerFromQPointF(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetTopRight(position QPointF_ITF) {
|
|
defer qt.Recovering("QRectF::setTopRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetTopRight(ptr.Pointer(), PointerFromQPointF(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetWidth(width float64) {
|
|
defer qt.Recovering("QRectF::setWidth")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetWidth(ptr.Pointer(), C.double(width))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetX(x float64) {
|
|
defer qt.Recovering("QRectF::setX")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetX(ptr.Pointer(), C.double(x))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) SetY(y float64) {
|
|
defer qt.Recovering("QRectF::setY")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_SetY(ptr.Pointer(), C.double(y))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) Size() *QSizeF {
|
|
defer qt.Recovering("QRectF::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFFromPointer(C.QRectF_Size(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) ToRect() *QRect {
|
|
defer qt.Recovering("QRectF::toRect")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFromPointer(C.QRectF_ToRect(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) Top() float64 {
|
|
defer qt.Recovering("QRectF::top")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QRectF_Top(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRectF) TopLeft() *QPointF {
|
|
defer qt.Recovering("QRectF::topLeft")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFFromPointer(C.QRectF_TopLeft(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) TopRight() *QPointF {
|
|
defer qt.Recovering("QRectF::topRight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFFromPointer(C.QRectF_TopRight(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) Translate2(offset QPointF_ITF) {
|
|
defer qt.Recovering("QRectF::translate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_Translate2(ptr.Pointer(), PointerFromQPointF(offset))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) Translate(dx float64, dy float64) {
|
|
defer qt.Recovering("QRectF::translate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRectF_Translate(ptr.Pointer(), C.double(dx), C.double(dy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRectF) Translated2(offset QPointF_ITF) *QRectF {
|
|
defer qt.Recovering("QRectF::translated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFFromPointer(C.QRectF_Translated2(ptr.Pointer(), PointerFromQPointF(offset)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) Translated(dx float64, dy float64) *QRectF {
|
|
defer qt.Recovering("QRectF::translated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFFromPointer(C.QRectF_Translated(ptr.Pointer(), C.double(dx), C.double(dy)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) United(rectangle QRectF_ITF) *QRectF {
|
|
defer qt.Recovering("QRectF::united")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFFromPointer(C.QRectF_United(ptr.Pointer(), PointerFromQRectF(rectangle)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRectF) Width() float64 {
|
|
defer qt.Recovering("QRectF::width")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QRectF_Width(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRectF) X() float64 {
|
|
defer qt.Recovering("QRectF::x")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QRectF_X(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRectF) Y() float64 {
|
|
defer qt.Recovering("QRectF::y")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QRectF_Y(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//QRegExp::CaretMode
|
|
type QRegExp__CaretMode int64
|
|
|
|
const (
|
|
QRegExp__CaretAtZero = QRegExp__CaretMode(0)
|
|
QRegExp__CaretAtOffset = QRegExp__CaretMode(1)
|
|
QRegExp__CaretWontMatch = QRegExp__CaretMode(2)
|
|
)
|
|
|
|
//QRegExp::PatternSyntax
|
|
type QRegExp__PatternSyntax int64
|
|
|
|
const (
|
|
QRegExp__RegExp = QRegExp__PatternSyntax(0)
|
|
QRegExp__Wildcard = QRegExp__PatternSyntax(1)
|
|
QRegExp__FixedString = QRegExp__PatternSyntax(2)
|
|
QRegExp__RegExp2 = QRegExp__PatternSyntax(3)
|
|
QRegExp__WildcardUnix = QRegExp__PatternSyntax(4)
|
|
QRegExp__W3CXmlSchema11 = QRegExp__PatternSyntax(5)
|
|
)
|
|
|
|
type QRegExp struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QRegExp_ITF interface {
|
|
QRegExp_PTR() *QRegExp
|
|
}
|
|
|
|
func (p *QRegExp) QRegExp_PTR() *QRegExp {
|
|
return p
|
|
}
|
|
|
|
func (p *QRegExp) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QRegExp) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQRegExp(ptr QRegExp_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QRegExp_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQRegExpFromPointer(ptr unsafe.Pointer) *QRegExp {
|
|
var n = new(QRegExp)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQRegExpFromPointer(ptr unsafe.Pointer) *QRegExp {
|
|
var n = NewQRegExpFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQRegExp() *QRegExp {
|
|
defer qt.Recovering("QRegExp::QRegExp")
|
|
|
|
return newQRegExpFromPointer(C.QRegExp_NewQRegExp())
|
|
}
|
|
|
|
func NewQRegExp3(rx QRegExp_ITF) *QRegExp {
|
|
defer qt.Recovering("QRegExp::QRegExp")
|
|
|
|
return newQRegExpFromPointer(C.QRegExp_NewQRegExp3(PointerFromQRegExp(rx)))
|
|
}
|
|
|
|
func NewQRegExp2(pattern string, cs Qt__CaseSensitivity, syntax QRegExp__PatternSyntax) *QRegExp {
|
|
defer qt.Recovering("QRegExp::QRegExp")
|
|
|
|
return newQRegExpFromPointer(C.QRegExp_NewQRegExp2(C.CString(pattern), C.int(cs), C.int(syntax)))
|
|
}
|
|
|
|
func (ptr *QRegExp) Cap(nth int) string {
|
|
defer qt.Recovering("QRegExp::cap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QRegExp_Cap(ptr.Pointer(), C.int(nth)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRegExp) ErrorString() string {
|
|
defer qt.Recovering("QRegExp::errorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QRegExp_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRegExp) CaptureCount() int {
|
|
defer qt.Recovering("QRegExp::captureCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegExp_CaptureCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegExp) CapturedTexts() []string {
|
|
defer qt.Recovering("QRegExp::capturedTexts")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QRegExp_CapturedTexts(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QRegExp) CaseSensitivity() Qt__CaseSensitivity {
|
|
defer qt.Recovering("QRegExp::caseSensitivity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__CaseSensitivity(C.QRegExp_CaseSensitivity(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QRegExp_Escape(str string) string {
|
|
defer qt.Recovering("QRegExp::escape")
|
|
|
|
return C.GoString(C.QRegExp_QRegExp_Escape(C.CString(str)))
|
|
}
|
|
|
|
func (ptr *QRegExp) Escape(str string) string {
|
|
defer qt.Recovering("QRegExp::escape")
|
|
|
|
return C.GoString(C.QRegExp_QRegExp_Escape(C.CString(str)))
|
|
}
|
|
|
|
func (ptr *QRegExp) ExactMatch(str string) bool {
|
|
defer qt.Recovering("QRegExp::exactMatch")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRegExp_ExactMatch(ptr.Pointer(), C.CString(str)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRegExp) IndexIn(str string, offset int, caretMode QRegExp__CaretMode) int {
|
|
defer qt.Recovering("QRegExp::indexIn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegExp_IndexIn(ptr.Pointer(), C.CString(str), C.int(offset), C.int(caretMode)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegExp) IsEmpty() bool {
|
|
defer qt.Recovering("QRegExp::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRegExp_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRegExp) IsMinimal() bool {
|
|
defer qt.Recovering("QRegExp::isMinimal")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRegExp_IsMinimal(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRegExp) IsValid() bool {
|
|
defer qt.Recovering("QRegExp::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRegExp_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRegExp) LastIndexIn(str string, offset int, caretMode QRegExp__CaretMode) int {
|
|
defer qt.Recovering("QRegExp::lastIndexIn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegExp_LastIndexIn(ptr.Pointer(), C.CString(str), C.int(offset), C.int(caretMode)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegExp) MatchedLength() int {
|
|
defer qt.Recovering("QRegExp::matchedLength")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegExp_MatchedLength(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegExp) Pattern() string {
|
|
defer qt.Recovering("QRegExp::pattern")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QRegExp_Pattern(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRegExp) PatternSyntax() QRegExp__PatternSyntax {
|
|
defer qt.Recovering("QRegExp::patternSyntax")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QRegExp__PatternSyntax(C.QRegExp_PatternSyntax(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegExp) Pos(nth int) int {
|
|
defer qt.Recovering("QRegExp::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegExp_Pos(ptr.Pointer(), C.int(nth)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegExp) SetCaseSensitivity(cs Qt__CaseSensitivity) {
|
|
defer qt.Recovering("QRegExp::setCaseSensitivity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegExp_SetCaseSensitivity(ptr.Pointer(), C.int(cs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRegExp) SetMinimal(minimal bool) {
|
|
defer qt.Recovering("QRegExp::setMinimal")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegExp_SetMinimal(ptr.Pointer(), C.int(qt.GoBoolToInt(minimal)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRegExp) SetPattern(pattern string) {
|
|
defer qt.Recovering("QRegExp::setPattern")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegExp_SetPattern(ptr.Pointer(), C.CString(pattern))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRegExp) SetPatternSyntax(syntax QRegExp__PatternSyntax) {
|
|
defer qt.Recovering("QRegExp::setPatternSyntax")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegExp_SetPatternSyntax(ptr.Pointer(), C.int(syntax))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRegExp) Swap(other QRegExp_ITF) {
|
|
defer qt.Recovering("QRegExp::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegExp_Swap(ptr.Pointer(), PointerFromQRegExp(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRegExp) DestroyQRegExp() {
|
|
defer qt.Recovering("QRegExp::~QRegExp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegExp_DestroyQRegExp(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QRegularExpression::MatchOption
|
|
type QRegularExpression__MatchOption int64
|
|
|
|
const (
|
|
QRegularExpression__NoMatchOption = QRegularExpression__MatchOption(0x0000)
|
|
QRegularExpression__AnchoredMatchOption = QRegularExpression__MatchOption(0x0001)
|
|
QRegularExpression__DontCheckSubjectStringMatchOption = QRegularExpression__MatchOption(0x0002)
|
|
)
|
|
|
|
//QRegularExpression::MatchType
|
|
type QRegularExpression__MatchType int64
|
|
|
|
const (
|
|
QRegularExpression__NormalMatch = QRegularExpression__MatchType(0)
|
|
QRegularExpression__PartialPreferCompleteMatch = QRegularExpression__MatchType(1)
|
|
QRegularExpression__PartialPreferFirstMatch = QRegularExpression__MatchType(2)
|
|
QRegularExpression__NoMatch = QRegularExpression__MatchType(3)
|
|
)
|
|
|
|
//QRegularExpression::PatternOption
|
|
type QRegularExpression__PatternOption int64
|
|
|
|
const (
|
|
QRegularExpression__NoPatternOption = QRegularExpression__PatternOption(0x0000)
|
|
QRegularExpression__CaseInsensitiveOption = QRegularExpression__PatternOption(0x0001)
|
|
QRegularExpression__DotMatchesEverythingOption = QRegularExpression__PatternOption(0x0002)
|
|
QRegularExpression__MultilineOption = QRegularExpression__PatternOption(0x0004)
|
|
QRegularExpression__ExtendedPatternSyntaxOption = QRegularExpression__PatternOption(0x0008)
|
|
QRegularExpression__InvertedGreedinessOption = QRegularExpression__PatternOption(0x0010)
|
|
QRegularExpression__DontCaptureOption = QRegularExpression__PatternOption(0x0020)
|
|
QRegularExpression__UseUnicodePropertiesOption = QRegularExpression__PatternOption(0x0040)
|
|
QRegularExpression__OptimizeOnFirstUsageOption = QRegularExpression__PatternOption(0x0080)
|
|
QRegularExpression__DontAutomaticallyOptimizeOption = QRegularExpression__PatternOption(0x0100)
|
|
)
|
|
|
|
type QRegularExpression struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QRegularExpression_ITF interface {
|
|
QRegularExpression_PTR() *QRegularExpression
|
|
}
|
|
|
|
func (p *QRegularExpression) QRegularExpression_PTR() *QRegularExpression {
|
|
return p
|
|
}
|
|
|
|
func (p *QRegularExpression) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QRegularExpression) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQRegularExpression(ptr QRegularExpression_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QRegularExpression_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQRegularExpressionFromPointer(ptr unsafe.Pointer) *QRegularExpression {
|
|
var n = new(QRegularExpression)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQRegularExpressionFromPointer(ptr unsafe.Pointer) *QRegularExpression {
|
|
var n = NewQRegularExpressionFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQRegularExpression() *QRegularExpression {
|
|
defer qt.Recovering("QRegularExpression::QRegularExpression")
|
|
|
|
return newQRegularExpressionFromPointer(C.QRegularExpression_NewQRegularExpression())
|
|
}
|
|
|
|
func NewQRegularExpression3(re QRegularExpression_ITF) *QRegularExpression {
|
|
defer qt.Recovering("QRegularExpression::QRegularExpression")
|
|
|
|
return newQRegularExpressionFromPointer(C.QRegularExpression_NewQRegularExpression3(PointerFromQRegularExpression(re)))
|
|
}
|
|
|
|
func NewQRegularExpression2(pattern string, options QRegularExpression__PatternOption) *QRegularExpression {
|
|
defer qt.Recovering("QRegularExpression::QRegularExpression")
|
|
|
|
return newQRegularExpressionFromPointer(C.QRegularExpression_NewQRegularExpression2(C.CString(pattern), C.int(options)))
|
|
}
|
|
|
|
func (ptr *QRegularExpression) CaptureCount() int {
|
|
defer qt.Recovering("QRegularExpression::captureCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegularExpression_CaptureCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegularExpression) ErrorString() string {
|
|
defer qt.Recovering("QRegularExpression::errorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QRegularExpression_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func QRegularExpression_Escape(str string) string {
|
|
defer qt.Recovering("QRegularExpression::escape")
|
|
|
|
return C.GoString(C.QRegularExpression_QRegularExpression_Escape(C.CString(str)))
|
|
}
|
|
|
|
func (ptr *QRegularExpression) Escape(str string) string {
|
|
defer qt.Recovering("QRegularExpression::escape")
|
|
|
|
return C.GoString(C.QRegularExpression_QRegularExpression_Escape(C.CString(str)))
|
|
}
|
|
|
|
func (ptr *QRegularExpression) GlobalMatch(subject string, offset int, matchType QRegularExpression__MatchType, matchOptions QRegularExpression__MatchOption) *QRegularExpressionMatchIterator {
|
|
defer qt.Recovering("QRegularExpression::globalMatch")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRegularExpressionMatchIteratorFromPointer(C.QRegularExpression_GlobalMatch(ptr.Pointer(), C.CString(subject), C.int(offset), C.int(matchType), C.int(matchOptions)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRegularExpression) GlobalMatch2(subjectRef QStringRef_ITF, offset int, matchType QRegularExpression__MatchType, matchOptions QRegularExpression__MatchOption) *QRegularExpressionMatchIterator {
|
|
defer qt.Recovering("QRegularExpression::globalMatch")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRegularExpressionMatchIteratorFromPointer(C.QRegularExpression_GlobalMatch2(ptr.Pointer(), PointerFromQStringRef(subjectRef), C.int(offset), C.int(matchType), C.int(matchOptions)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRegularExpression) IsValid() bool {
|
|
defer qt.Recovering("QRegularExpression::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRegularExpression_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRegularExpression) Match(subject string, offset int, matchType QRegularExpression__MatchType, matchOptions QRegularExpression__MatchOption) *QRegularExpressionMatch {
|
|
defer qt.Recovering("QRegularExpression::match")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRegularExpressionMatchFromPointer(C.QRegularExpression_Match(ptr.Pointer(), C.CString(subject), C.int(offset), C.int(matchType), C.int(matchOptions)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRegularExpression) Match2(subjectRef QStringRef_ITF, offset int, matchType QRegularExpression__MatchType, matchOptions QRegularExpression__MatchOption) *QRegularExpressionMatch {
|
|
defer qt.Recovering("QRegularExpression::match")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRegularExpressionMatchFromPointer(C.QRegularExpression_Match2(ptr.Pointer(), PointerFromQStringRef(subjectRef), C.int(offset), C.int(matchType), C.int(matchOptions)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRegularExpression) NamedCaptureGroups() []string {
|
|
defer qt.Recovering("QRegularExpression::namedCaptureGroups")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QRegularExpression_NamedCaptureGroups(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QRegularExpression) Optimize() {
|
|
defer qt.Recovering("QRegularExpression::optimize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegularExpression_Optimize(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QRegularExpression) Pattern() string {
|
|
defer qt.Recovering("QRegularExpression::pattern")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QRegularExpression_Pattern(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRegularExpression) PatternErrorOffset() int {
|
|
defer qt.Recovering("QRegularExpression::patternErrorOffset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegularExpression_PatternErrorOffset(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegularExpression) PatternOptions() QRegularExpression__PatternOption {
|
|
defer qt.Recovering("QRegularExpression::patternOptions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QRegularExpression__PatternOption(C.QRegularExpression_PatternOptions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegularExpression) SetPattern(pattern string) {
|
|
defer qt.Recovering("QRegularExpression::setPattern")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegularExpression_SetPattern(ptr.Pointer(), C.CString(pattern))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRegularExpression) SetPatternOptions(options QRegularExpression__PatternOption) {
|
|
defer qt.Recovering("QRegularExpression::setPatternOptions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegularExpression_SetPatternOptions(ptr.Pointer(), C.int(options))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRegularExpression) Swap(other QRegularExpression_ITF) {
|
|
defer qt.Recovering("QRegularExpression::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegularExpression_Swap(ptr.Pointer(), PointerFromQRegularExpression(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRegularExpression) DestroyQRegularExpression() {
|
|
defer qt.Recovering("QRegularExpression::~QRegularExpression")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegularExpression_DestroyQRegularExpression(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QRegularExpressionMatch struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QRegularExpressionMatch_ITF interface {
|
|
QRegularExpressionMatch_PTR() *QRegularExpressionMatch
|
|
}
|
|
|
|
func (p *QRegularExpressionMatch) QRegularExpressionMatch_PTR() *QRegularExpressionMatch {
|
|
return p
|
|
}
|
|
|
|
func (p *QRegularExpressionMatch) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QRegularExpressionMatch) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQRegularExpressionMatch(ptr QRegularExpressionMatch_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QRegularExpressionMatch_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQRegularExpressionMatchFromPointer(ptr unsafe.Pointer) *QRegularExpressionMatch {
|
|
var n = new(QRegularExpressionMatch)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQRegularExpressionMatchFromPointer(ptr unsafe.Pointer) *QRegularExpressionMatch {
|
|
var n = NewQRegularExpressionMatchFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQRegularExpressionMatch() *QRegularExpressionMatch {
|
|
defer qt.Recovering("QRegularExpressionMatch::QRegularExpressionMatch")
|
|
|
|
return newQRegularExpressionMatchFromPointer(C.QRegularExpressionMatch_NewQRegularExpressionMatch())
|
|
}
|
|
|
|
func NewQRegularExpressionMatch2(match QRegularExpressionMatch_ITF) *QRegularExpressionMatch {
|
|
defer qt.Recovering("QRegularExpressionMatch::QRegularExpressionMatch")
|
|
|
|
return newQRegularExpressionMatchFromPointer(C.QRegularExpressionMatch_NewQRegularExpressionMatch2(PointerFromQRegularExpressionMatch(match)))
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) Captured2(name string) string {
|
|
defer qt.Recovering("QRegularExpressionMatch::captured")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QRegularExpressionMatch_Captured2(ptr.Pointer(), C.CString(name)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) Captured(nth int) string {
|
|
defer qt.Recovering("QRegularExpressionMatch::captured")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QRegularExpressionMatch_Captured(ptr.Pointer(), C.int(nth)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) CapturedEnd2(name string) int {
|
|
defer qt.Recovering("QRegularExpressionMatch::capturedEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegularExpressionMatch_CapturedEnd2(ptr.Pointer(), C.CString(name)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) CapturedEnd(nth int) int {
|
|
defer qt.Recovering("QRegularExpressionMatch::capturedEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegularExpressionMatch_CapturedEnd(ptr.Pointer(), C.int(nth)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) CapturedLength2(name string) int {
|
|
defer qt.Recovering("QRegularExpressionMatch::capturedLength")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegularExpressionMatch_CapturedLength2(ptr.Pointer(), C.CString(name)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) CapturedLength(nth int) int {
|
|
defer qt.Recovering("QRegularExpressionMatch::capturedLength")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegularExpressionMatch_CapturedLength(ptr.Pointer(), C.int(nth)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) CapturedRef2(name string) *QStringRef {
|
|
defer qt.Recovering("QRegularExpressionMatch::capturedRef")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QRegularExpressionMatch_CapturedRef2(ptr.Pointer(), C.CString(name)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) CapturedRef(nth int) *QStringRef {
|
|
defer qt.Recovering("QRegularExpressionMatch::capturedRef")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QRegularExpressionMatch_CapturedRef(ptr.Pointer(), C.int(nth)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) CapturedStart2(name string) int {
|
|
defer qt.Recovering("QRegularExpressionMatch::capturedStart")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegularExpressionMatch_CapturedStart2(ptr.Pointer(), C.CString(name)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) CapturedStart(nth int) int {
|
|
defer qt.Recovering("QRegularExpressionMatch::capturedStart")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegularExpressionMatch_CapturedStart(ptr.Pointer(), C.int(nth)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) CapturedTexts() []string {
|
|
defer qt.Recovering("QRegularExpressionMatch::capturedTexts")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QRegularExpressionMatch_CapturedTexts(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) HasMatch() bool {
|
|
defer qt.Recovering("QRegularExpressionMatch::hasMatch")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRegularExpressionMatch_HasMatch(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) HasPartialMatch() bool {
|
|
defer qt.Recovering("QRegularExpressionMatch::hasPartialMatch")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRegularExpressionMatch_HasPartialMatch(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) IsValid() bool {
|
|
defer qt.Recovering("QRegularExpressionMatch::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRegularExpressionMatch_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) LastCapturedIndex() int {
|
|
defer qt.Recovering("QRegularExpressionMatch::lastCapturedIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QRegularExpressionMatch_LastCapturedIndex(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) MatchOptions() QRegularExpression__MatchOption {
|
|
defer qt.Recovering("QRegularExpressionMatch::matchOptions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QRegularExpression__MatchOption(C.QRegularExpressionMatch_MatchOptions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) MatchType() QRegularExpression__MatchType {
|
|
defer qt.Recovering("QRegularExpressionMatch::matchType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QRegularExpression__MatchType(C.QRegularExpressionMatch_MatchType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) RegularExpression() *QRegularExpression {
|
|
defer qt.Recovering("QRegularExpressionMatch::regularExpression")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRegularExpressionFromPointer(C.QRegularExpressionMatch_RegularExpression(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) Swap(other QRegularExpressionMatch_ITF) {
|
|
defer qt.Recovering("QRegularExpressionMatch::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegularExpressionMatch_Swap(ptr.Pointer(), PointerFromQRegularExpressionMatch(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRegularExpressionMatch) DestroyQRegularExpressionMatch() {
|
|
defer qt.Recovering("QRegularExpressionMatch::~QRegularExpressionMatch")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRegularExpressionMatch_DestroyQRegularExpressionMatch(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QRegularExpressionMatchIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QRegularExpressionMatchIterator_ITF interface {
|
|
QRegularExpressionMatchIterator_PTR() *QRegularExpressionMatchIterator
|
|
}
|
|
|
|
func (p *QRegularExpressionMatchIterator) QRegularExpressionMatchIterator_PTR() *QRegularExpressionMatchIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QRegularExpressionMatchIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QRegularExpressionMatchIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQRegularExpressionMatchIterator(ptr QRegularExpressionMatchIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QRegularExpressionMatchIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQRegularExpressionMatchIteratorFromPointer(ptr unsafe.Pointer) *QRegularExpressionMatchIterator {
|
|
var n = new(QRegularExpressionMatchIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQRegularExpressionMatchIteratorFromPointer(ptr unsafe.Pointer) *QRegularExpressionMatchIterator {
|
|
var n = NewQRegularExpressionMatchIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QResource struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QResource_ITF interface {
|
|
QResource_PTR() *QResource
|
|
}
|
|
|
|
func (p *QResource) QResource_PTR() *QResource {
|
|
return p
|
|
}
|
|
|
|
func (p *QResource) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QResource) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQResource(ptr QResource_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QResource_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQResourceFromPointer(ptr unsafe.Pointer) *QResource {
|
|
var n = new(QResource)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQResourceFromPointer(ptr unsafe.Pointer) *QResource {
|
|
var n = NewQResourceFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func QResource_RegisterResource(rccFileName string, mapRoot string) bool {
|
|
defer qt.Recovering("QResource::registerResource")
|
|
|
|
return C.QResource_QResource_RegisterResource(C.CString(rccFileName), C.CString(mapRoot)) != 0
|
|
}
|
|
|
|
func (ptr *QResource) RegisterResource(rccFileName string, mapRoot string) bool {
|
|
defer qt.Recovering("QResource::registerResource")
|
|
|
|
return C.QResource_QResource_RegisterResource(C.CString(rccFileName), C.CString(mapRoot)) != 0
|
|
}
|
|
|
|
func QResource_UnregisterResource(rccFileName string, mapRoot string) bool {
|
|
defer qt.Recovering("QResource::unregisterResource")
|
|
|
|
return C.QResource_QResource_UnregisterResource(C.CString(rccFileName), C.CString(mapRoot)) != 0
|
|
}
|
|
|
|
func (ptr *QResource) UnregisterResource(rccFileName string, mapRoot string) bool {
|
|
defer qt.Recovering("QResource::unregisterResource")
|
|
|
|
return C.QResource_QResource_UnregisterResource(C.CString(rccFileName), C.CString(mapRoot)) != 0
|
|
}
|
|
|
|
func NewQResource(file string, locale QLocale_ITF) *QResource {
|
|
defer qt.Recovering("QResource::QResource")
|
|
|
|
return newQResourceFromPointer(C.QResource_NewQResource(C.CString(file), PointerFromQLocale(locale)))
|
|
}
|
|
|
|
func (ptr *QResource) AbsoluteFilePath() string {
|
|
defer qt.Recovering("QResource::absoluteFilePath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QResource_AbsoluteFilePath(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QResource) Children() []string {
|
|
defer qt.Recovering("QResource::children")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QResource_Children(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QResource) FileName() string {
|
|
defer qt.Recovering("QResource::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QResource_FileName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QResource) IsCompressed() bool {
|
|
defer qt.Recovering("QResource::isCompressed")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QResource_IsCompressed(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QResource) IsDir() bool {
|
|
defer qt.Recovering("QResource::isDir")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QResource_IsDir(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QResource) IsFile() bool {
|
|
defer qt.Recovering("QResource::isFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QResource_IsFile(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QResource) IsValid() bool {
|
|
defer qt.Recovering("QResource::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QResource_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QResource) Locale() *QLocale {
|
|
defer qt.Recovering("QResource::locale")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLocaleFromPointer(C.QResource_Locale(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QResource) SetFileName(file string) {
|
|
defer qt.Recovering("QResource::setFileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QResource_SetFileName(ptr.Pointer(), C.CString(file))
|
|
}
|
|
}
|
|
|
|
func (ptr *QResource) SetLocale(locale QLocale_ITF) {
|
|
defer qt.Recovering("QResource::setLocale")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QResource_SetLocale(ptr.Pointer(), PointerFromQLocale(locale))
|
|
}
|
|
}
|
|
|
|
func (ptr *QResource) Size() int64 {
|
|
defer qt.Recovering("QResource::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QResource_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QResource) DestroyQResource() {
|
|
defer qt.Recovering("QResource::~QResource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QResource_DestroyQResource(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QRunnable struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QRunnable_ITF interface {
|
|
QRunnable_PTR() *QRunnable
|
|
}
|
|
|
|
func (p *QRunnable) QRunnable_PTR() *QRunnable {
|
|
return p
|
|
}
|
|
|
|
func (p *QRunnable) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QRunnable) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQRunnable(ptr QRunnable_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QRunnable_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQRunnableFromPointer(ptr unsafe.Pointer) *QRunnable {
|
|
var n = new(QRunnable)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQRunnableFromPointer(ptr unsafe.Pointer) *QRunnable {
|
|
var n = NewQRunnableFromPointer(ptr)
|
|
for len(n.ObjectNameAbs()) < len("QRunnable_") {
|
|
n.SetObjectNameAbs("QRunnable_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QRunnable) DestroyQRunnable() {
|
|
defer qt.Recovering("QRunnable::~QRunnable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectNameAbs())
|
|
C.QRunnable_DestroyQRunnable(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func NewQRunnable() *QRunnable {
|
|
defer qt.Recovering("QRunnable::QRunnable")
|
|
|
|
return newQRunnableFromPointer(C.QRunnable_NewQRunnable())
|
|
}
|
|
|
|
func (ptr *QRunnable) AutoDelete() bool {
|
|
defer qt.Recovering("QRunnable::autoDelete")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QRunnable_AutoDelete(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRunnable_Run
|
|
func callbackQRunnable_Run(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QRunnable::run")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "run"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRunnable) ConnectRun(f func()) {
|
|
defer qt.Recovering("connect QRunnable::run")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectNameAbs(), "run", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRunnable) DisconnectRun() {
|
|
defer qt.Recovering("disconnect QRunnable::run")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectNameAbs(), "run")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRunnable) Run() {
|
|
defer qt.Recovering("QRunnable::run")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRunnable_Run(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QRunnable) SetAutoDelete(autoDelete bool) {
|
|
defer qt.Recovering("QRunnable::setAutoDelete")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRunnable_SetAutoDelete(ptr.Pointer(), C.int(qt.GoBoolToInt(autoDelete)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRunnable) ObjectNameAbs() string {
|
|
defer qt.Recovering("QRunnable::objectNameAbs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QRunnable_ObjectNameAbs(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRunnable) SetObjectNameAbs(name string) {
|
|
defer qt.Recovering("QRunnable::setObjectNameAbs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QRunnable_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
|
|
}
|
|
}
|
|
|
|
type QSaveFile struct {
|
|
QFileDevice
|
|
}
|
|
|
|
type QSaveFile_ITF interface {
|
|
QFileDevice_ITF
|
|
QSaveFile_PTR() *QSaveFile
|
|
}
|
|
|
|
func (p *QSaveFile) QSaveFile_PTR() *QSaveFile {
|
|
return p
|
|
}
|
|
|
|
func (p *QSaveFile) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QFileDevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSaveFile) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QFileDevice_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQSaveFile(ptr QSaveFile_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSaveFile_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSaveFileFromPointer(ptr unsafe.Pointer) *QSaveFile {
|
|
var n = new(QSaveFile)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSaveFileFromPointer(ptr unsafe.Pointer) *QSaveFile {
|
|
var n = NewQSaveFileFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QSaveFile_") {
|
|
n.SetObjectName("QSaveFile_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQSaveFile2(parent QObject_ITF) *QSaveFile {
|
|
defer qt.Recovering("QSaveFile::QSaveFile")
|
|
|
|
return newQSaveFileFromPointer(C.QSaveFile_NewQSaveFile2(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQSaveFile(name string) *QSaveFile {
|
|
defer qt.Recovering("QSaveFile::QSaveFile")
|
|
|
|
return newQSaveFileFromPointer(C.QSaveFile_NewQSaveFile(C.CString(name)))
|
|
}
|
|
|
|
func NewQSaveFile3(name string, parent QObject_ITF) *QSaveFile {
|
|
defer qt.Recovering("QSaveFile::QSaveFile")
|
|
|
|
return newQSaveFileFromPointer(C.QSaveFile_NewQSaveFile3(C.CString(name), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QSaveFile) CancelWriting() {
|
|
defer qt.Recovering("QSaveFile::cancelWriting")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_CancelWriting(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) Commit() bool {
|
|
defer qt.Recovering("QSaveFile::commit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_Commit(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) DirectWriteFallback() bool {
|
|
defer qt.Recovering("QSaveFile::directWriteFallback")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_DirectWriteFallback(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSaveFile_FileName
|
|
func callbackQSaveFile_FileName(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QSaveFile::fileName")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "fileName"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString(NewQSaveFileFromPointer(ptr).FileNameDefault())
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectFileName(f func() string) {
|
|
defer qt.Recovering("connect QSaveFile::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "fileName", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectFileName() {
|
|
defer qt.Recovering("disconnect QSaveFile::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "fileName")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) FileName() string {
|
|
defer qt.Recovering("QSaveFile::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QSaveFile_FileName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QSaveFile) FileNameDefault() string {
|
|
defer qt.Recovering("QSaveFile::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QSaveFile_FileNameDefault(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQSaveFile_Open
|
|
func callbackQSaveFile_Open(ptr unsafe.Pointer, ptrName *C.char, mode C.int) C.int {
|
|
defer qt.Recovering("callback QSaveFile::open")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "open"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(QIODevice__OpenModeFlag) bool)(QIODevice__OpenModeFlag(mode))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSaveFileFromPointer(ptr).OpenDefault(QIODevice__OpenModeFlag(mode))))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectOpen(f func(mode QIODevice__OpenModeFlag) bool) {
|
|
defer qt.Recovering("connect QSaveFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "open", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectOpen() {
|
|
defer qt.Recovering("disconnect QSaveFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "open")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) Open(mode QIODevice__OpenModeFlag) bool {
|
|
defer qt.Recovering("QSaveFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_Open(ptr.Pointer(), C.int(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) OpenDefault(mode QIODevice__OpenModeFlag) bool {
|
|
defer qt.Recovering("QSaveFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_OpenDefault(ptr.Pointer(), C.int(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) SetDirectWriteFallback(enabled bool) {
|
|
defer qt.Recovering("QSaveFile::setDirectWriteFallback")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_SetDirectWriteFallback(ptr.Pointer(), C.int(qt.GoBoolToInt(enabled)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) SetFileName(name string) {
|
|
defer qt.Recovering("QSaveFile::setFileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_SetFileName(ptr.Pointer(), C.CString(name))
|
|
}
|
|
}
|
|
|
|
//export callbackQSaveFile_WriteData
|
|
func callbackQSaveFile_WriteData(ptr unsafe.Pointer, ptrName *C.char, data *C.char, len C.longlong) C.longlong {
|
|
defer qt.Recovering("callback QSaveFile::writeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "writeData"); signal != nil {
|
|
return C.longlong(signal.(func(string, int64) int64)(C.GoString(data), int64(len)))
|
|
}
|
|
|
|
return C.longlong(NewQSaveFileFromPointer(ptr).WriteDataDefault(C.GoString(data), int64(len)))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectWriteData(f func(data string, len int64) int64) {
|
|
defer qt.Recovering("connect QSaveFile::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "writeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectWriteData() {
|
|
defer qt.Recovering("disconnect QSaveFile::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "writeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) WriteData(data string, len int64) int64 {
|
|
defer qt.Recovering("QSaveFile::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QSaveFile_WriteData(ptr.Pointer(), C.CString(data), C.longlong(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSaveFile) WriteDataDefault(data string, len int64) int64 {
|
|
defer qt.Recovering("QSaveFile::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QSaveFile_WriteDataDefault(ptr.Pointer(), C.CString(data), C.longlong(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSaveFile) DestroyQSaveFile() {
|
|
defer qt.Recovering("QSaveFile::~QSaveFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSaveFile_DestroyQSaveFile(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSaveFile_Seek
|
|
func callbackQSaveFile_Seek(ptr unsafe.Pointer, ptrName *C.char, pos C.longlong) C.int {
|
|
defer qt.Recovering("callback QSaveFile::seek")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "seek"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int64) bool)(int64(pos))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSaveFileFromPointer(ptr).SeekDefault(int64(pos))))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectSeek(f func(pos int64) bool) {
|
|
defer qt.Recovering("connect QSaveFile::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "seek", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectSeek() {
|
|
defer qt.Recovering("disconnect QSaveFile::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "seek")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) Seek(pos int64) bool {
|
|
defer qt.Recovering("QSaveFile::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_Seek(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) SeekDefault(pos int64) bool {
|
|
defer qt.Recovering("QSaveFile::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_SeekDefault(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSaveFile_AtEnd
|
|
func callbackQSaveFile_AtEnd(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QSaveFile::atEnd")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "atEnd"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSaveFileFromPointer(ptr).AtEndDefault()))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectAtEnd(f func() bool) {
|
|
defer qt.Recovering("connect QSaveFile::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "atEnd", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectAtEnd() {
|
|
defer qt.Recovering("disconnect QSaveFile::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "atEnd")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) AtEnd() bool {
|
|
defer qt.Recovering("QSaveFile::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_AtEnd(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) AtEndDefault() bool {
|
|
defer qt.Recovering("QSaveFile::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_AtEndDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSaveFile_Close
|
|
func callbackQSaveFile_Close(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSaveFile::close")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSaveFileFromPointer(ptr).CloseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectClose(f func()) {
|
|
defer qt.Recovering("connect QSaveFile::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "close", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectClose() {
|
|
defer qt.Recovering("disconnect QSaveFile::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "close")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) Close() {
|
|
defer qt.Recovering("QSaveFile::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_Close(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) CloseDefault() {
|
|
defer qt.Recovering("QSaveFile::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_CloseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSaveFile_IsSequential
|
|
func callbackQSaveFile_IsSequential(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QSaveFile::isSequential")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "isSequential"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSaveFileFromPointer(ptr).IsSequentialDefault()))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectIsSequential(f func() bool) {
|
|
defer qt.Recovering("connect QSaveFile::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "isSequential", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectIsSequential() {
|
|
defer qt.Recovering("disconnect QSaveFile::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "isSequential")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) IsSequential() bool {
|
|
defer qt.Recovering("QSaveFile::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_IsSequential(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) IsSequentialDefault() bool {
|
|
defer qt.Recovering("QSaveFile::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_IsSequentialDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSaveFile_Permissions
|
|
func callbackQSaveFile_Permissions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QSaveFile::permissions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "permissions"); signal != nil {
|
|
return C.int(signal.(func() QFileDevice__Permission)())
|
|
}
|
|
|
|
return C.int(NewQSaveFileFromPointer(ptr).PermissionsDefault())
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectPermissions(f func() QFileDevice__Permission) {
|
|
defer qt.Recovering("connect QSaveFile::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "permissions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectPermissions() {
|
|
defer qt.Recovering("disconnect QSaveFile::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "permissions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) Permissions() QFileDevice__Permission {
|
|
defer qt.Recovering("QSaveFile::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QFileDevice__Permission(C.QSaveFile_Permissions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSaveFile) PermissionsDefault() QFileDevice__Permission {
|
|
defer qt.Recovering("QSaveFile::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QFileDevice__Permission(C.QSaveFile_PermissionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSaveFile_Pos
|
|
func callbackQSaveFile_Pos(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QSaveFile::pos")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pos"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQSaveFileFromPointer(ptr).PosDefault())
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectPos(f func() int64) {
|
|
defer qt.Recovering("connect QSaveFile::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pos", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectPos() {
|
|
defer qt.Recovering("disconnect QSaveFile::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pos")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) Pos() int64 {
|
|
defer qt.Recovering("QSaveFile::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QSaveFile_Pos(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSaveFile) PosDefault() int64 {
|
|
defer qt.Recovering("QSaveFile::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QSaveFile_PosDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSaveFile_ReadLineData
|
|
func callbackQSaveFile_ReadLineData(ptr unsafe.Pointer, ptrName *C.char, data *C.char, maxlen C.longlong) C.longlong {
|
|
defer qt.Recovering("callback QSaveFile::readLineData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "readLineData"); signal != nil {
|
|
return C.longlong(signal.(func(string, int64) int64)(C.GoString(data), int64(maxlen)))
|
|
}
|
|
|
|
return C.longlong(NewQSaveFileFromPointer(ptr).ReadLineDataDefault(C.GoString(data), int64(maxlen)))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectReadLineData(f func(data string, maxlen int64) int64) {
|
|
defer qt.Recovering("connect QSaveFile::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "readLineData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectReadLineData() {
|
|
defer qt.Recovering("disconnect QSaveFile::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "readLineData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) ReadLineData(data string, maxlen int64) int64 {
|
|
defer qt.Recovering("QSaveFile::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QSaveFile_ReadLineData(ptr.Pointer(), C.CString(data), C.longlong(maxlen)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSaveFile) ReadLineDataDefault(data string, maxlen int64) int64 {
|
|
defer qt.Recovering("QSaveFile::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QSaveFile_ReadLineDataDefault(ptr.Pointer(), C.CString(data), C.longlong(maxlen)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSaveFile_Resize
|
|
func callbackQSaveFile_Resize(ptr unsafe.Pointer, ptrName *C.char, sz C.longlong) C.int {
|
|
defer qt.Recovering("callback QSaveFile::resize")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resize"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int64) bool)(int64(sz))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSaveFileFromPointer(ptr).ResizeDefault(int64(sz))))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectResize(f func(sz int64) bool) {
|
|
defer qt.Recovering("connect QSaveFile::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resize", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectResize() {
|
|
defer qt.Recovering("disconnect QSaveFile::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resize")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) Resize(sz int64) bool {
|
|
defer qt.Recovering("QSaveFile::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_Resize(ptr.Pointer(), C.longlong(sz)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) ResizeDefault(sz int64) bool {
|
|
defer qt.Recovering("QSaveFile::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_ResizeDefault(ptr.Pointer(), C.longlong(sz)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSaveFile_SetPermissions
|
|
func callbackQSaveFile_SetPermissions(ptr unsafe.Pointer, ptrName *C.char, permissions C.int) C.int {
|
|
defer qt.Recovering("callback QSaveFile::setPermissions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setPermissions"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(QFileDevice__Permission) bool)(QFileDevice__Permission(permissions))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSaveFileFromPointer(ptr).SetPermissionsDefault(QFileDevice__Permission(permissions))))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectSetPermissions(f func(permissions QFileDevice__Permission) bool) {
|
|
defer qt.Recovering("connect QSaveFile::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setPermissions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectSetPermissions() {
|
|
defer qt.Recovering("disconnect QSaveFile::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setPermissions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) SetPermissions(permissions QFileDevice__Permission) bool {
|
|
defer qt.Recovering("QSaveFile::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_SetPermissions(ptr.Pointer(), C.int(permissions)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) SetPermissionsDefault(permissions QFileDevice__Permission) bool {
|
|
defer qt.Recovering("QSaveFile::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_SetPermissionsDefault(ptr.Pointer(), C.int(permissions)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSaveFile_Size
|
|
func callbackQSaveFile_Size(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QSaveFile::size")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "size"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQSaveFileFromPointer(ptr).SizeDefault())
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectSize(f func() int64) {
|
|
defer qt.Recovering("connect QSaveFile::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "size", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectSize() {
|
|
defer qt.Recovering("disconnect QSaveFile::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "size")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) Size() int64 {
|
|
defer qt.Recovering("QSaveFile::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QSaveFile_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSaveFile) SizeDefault() int64 {
|
|
defer qt.Recovering("QSaveFile::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QSaveFile_SizeDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSaveFile_BytesAvailable
|
|
func callbackQSaveFile_BytesAvailable(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QSaveFile::bytesAvailable")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesAvailable"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQSaveFileFromPointer(ptr).BytesAvailableDefault())
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectBytesAvailable(f func() int64) {
|
|
defer qt.Recovering("connect QSaveFile::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesAvailable", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectBytesAvailable() {
|
|
defer qt.Recovering("disconnect QSaveFile::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) BytesAvailable() int64 {
|
|
defer qt.Recovering("QSaveFile::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QSaveFile_BytesAvailable(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSaveFile) BytesAvailableDefault() int64 {
|
|
defer qt.Recovering("QSaveFile::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QSaveFile_BytesAvailableDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSaveFile_BytesToWrite
|
|
func callbackQSaveFile_BytesToWrite(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QSaveFile::bytesToWrite")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesToWrite"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQSaveFileFromPointer(ptr).BytesToWriteDefault())
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectBytesToWrite(f func() int64) {
|
|
defer qt.Recovering("connect QSaveFile::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesToWrite", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectBytesToWrite() {
|
|
defer qt.Recovering("disconnect QSaveFile::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesToWrite")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) BytesToWrite() int64 {
|
|
defer qt.Recovering("QSaveFile::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QSaveFile_BytesToWrite(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSaveFile) BytesToWriteDefault() int64 {
|
|
defer qt.Recovering("QSaveFile::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QSaveFile_BytesToWriteDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSaveFile_CanReadLine
|
|
func callbackQSaveFile_CanReadLine(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QSaveFile::canReadLine")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canReadLine"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSaveFileFromPointer(ptr).CanReadLineDefault()))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectCanReadLine(f func() bool) {
|
|
defer qt.Recovering("connect QSaveFile::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canReadLine", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectCanReadLine() {
|
|
defer qt.Recovering("disconnect QSaveFile::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canReadLine")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) CanReadLine() bool {
|
|
defer qt.Recovering("QSaveFile::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_CanReadLine(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) CanReadLineDefault() bool {
|
|
defer qt.Recovering("QSaveFile::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_CanReadLineDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSaveFile_Reset
|
|
func callbackQSaveFile_Reset(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QSaveFile::reset")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "reset"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSaveFileFromPointer(ptr).ResetDefault()))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectReset(f func() bool) {
|
|
defer qt.Recovering("connect QSaveFile::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "reset", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectReset() {
|
|
defer qt.Recovering("disconnect QSaveFile::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "reset")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) Reset() bool {
|
|
defer qt.Recovering("QSaveFile::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_Reset(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) ResetDefault() bool {
|
|
defer qt.Recovering("QSaveFile::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_ResetDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSaveFile_WaitForBytesWritten
|
|
func callbackQSaveFile_WaitForBytesWritten(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) C.int {
|
|
defer qt.Recovering("callback QSaveFile::waitForBytesWritten")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "waitForBytesWritten"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(msecs))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSaveFileFromPointer(ptr).WaitForBytesWrittenDefault(int(msecs))))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectWaitForBytesWritten(f func(msecs int) bool) {
|
|
defer qt.Recovering("connect QSaveFile::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "waitForBytesWritten", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectWaitForBytesWritten() {
|
|
defer qt.Recovering("disconnect QSaveFile::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "waitForBytesWritten")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) WaitForBytesWritten(msecs int) bool {
|
|
defer qt.Recovering("QSaveFile::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_WaitForBytesWritten(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) WaitForBytesWrittenDefault(msecs int) bool {
|
|
defer qt.Recovering("QSaveFile::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_WaitForBytesWrittenDefault(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSaveFile_WaitForReadyRead
|
|
func callbackQSaveFile_WaitForReadyRead(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) C.int {
|
|
defer qt.Recovering("callback QSaveFile::waitForReadyRead")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "waitForReadyRead"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(msecs))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSaveFileFromPointer(ptr).WaitForReadyReadDefault(int(msecs))))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectWaitForReadyRead(f func(msecs int) bool) {
|
|
defer qt.Recovering("connect QSaveFile::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "waitForReadyRead", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectWaitForReadyRead() {
|
|
defer qt.Recovering("disconnect QSaveFile::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "waitForReadyRead")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) WaitForReadyRead(msecs int) bool {
|
|
defer qt.Recovering("QSaveFile::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_WaitForReadyRead(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) WaitForReadyReadDefault(msecs int) bool {
|
|
defer qt.Recovering("QSaveFile::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_WaitForReadyReadDefault(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSaveFile_TimerEvent
|
|
func callbackQSaveFile_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSaveFile::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQSaveFileFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QSaveFile::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QSaveFile::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSaveFile::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSaveFile::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSaveFile_ChildEvent
|
|
func callbackQSaveFile_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSaveFile::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQSaveFileFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QSaveFile::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QSaveFile::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSaveFile::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSaveFile::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSaveFile_ConnectNotify
|
|
func callbackQSaveFile_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSaveFile::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSaveFileFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSaveFile::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QSaveFile::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSaveFile::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSaveFile::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSaveFile_CustomEvent
|
|
func callbackQSaveFile_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSaveFile::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQSaveFileFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QSaveFile::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QSaveFile::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QSaveFile::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QSaveFile::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSaveFile_DeleteLater
|
|
func callbackQSaveFile_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSaveFile::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSaveFileFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QSaveFile::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QSaveFile::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DeleteLater() {
|
|
defer qt.Recovering("QSaveFile::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSaveFile_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DeleteLaterDefault() {
|
|
defer qt.Recovering("QSaveFile::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSaveFile_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSaveFile_DisconnectNotify
|
|
func callbackQSaveFile_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSaveFile::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSaveFileFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSaveFile::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QSaveFile::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSaveFile::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSaveFile::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSaveFile_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSaveFile_Event
|
|
func callbackQSaveFile_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSaveFile::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSaveFileFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QSaveFile::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QSaveFile::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QSaveFile::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QSaveFile::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSaveFile_EventFilter
|
|
func callbackQSaveFile_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSaveFile::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSaveFileFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QSaveFile::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QSaveFile::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSaveFile::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSaveFile) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSaveFile::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSaveFile_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSaveFile_MetaObject
|
|
func callbackQSaveFile_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSaveFile::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQSaveFileFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QSaveFile) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QSaveFile::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QSaveFile::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSaveFile) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QSaveFile::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSaveFile_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSaveFile) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QSaveFile::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSaveFile_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QScopedArrayPointer struct {
|
|
QScopedPointer
|
|
}
|
|
|
|
type QScopedArrayPointer_ITF interface {
|
|
QScopedPointer_ITF
|
|
QScopedArrayPointer_PTR() *QScopedArrayPointer
|
|
}
|
|
|
|
func (p *QScopedArrayPointer) QScopedArrayPointer_PTR() *QScopedArrayPointer {
|
|
return p
|
|
}
|
|
|
|
func (p *QScopedArrayPointer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QScopedPointer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QScopedArrayPointer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QScopedPointer_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQScopedArrayPointer(ptr QScopedArrayPointer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QScopedArrayPointer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQScopedArrayPointerFromPointer(ptr unsafe.Pointer) *QScopedArrayPointer {
|
|
var n = new(QScopedArrayPointer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQScopedArrayPointerFromPointer(ptr unsafe.Pointer) *QScopedArrayPointer {
|
|
var n = NewQScopedArrayPointerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QScopedPointer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QScopedPointer_ITF interface {
|
|
QScopedPointer_PTR() *QScopedPointer
|
|
}
|
|
|
|
func (p *QScopedPointer) QScopedPointer_PTR() *QScopedPointer {
|
|
return p
|
|
}
|
|
|
|
func (p *QScopedPointer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QScopedPointer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQScopedPointer(ptr QScopedPointer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QScopedPointer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQScopedPointerFromPointer(ptr unsafe.Pointer) *QScopedPointer {
|
|
var n = new(QScopedPointer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQScopedPointerFromPointer(ptr unsafe.Pointer) *QScopedPointer {
|
|
var n = NewQScopedPointerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QScopedValueRollback struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QScopedValueRollback_ITF interface {
|
|
QScopedValueRollback_PTR() *QScopedValueRollback
|
|
}
|
|
|
|
func (p *QScopedValueRollback) QScopedValueRollback_PTR() *QScopedValueRollback {
|
|
return p
|
|
}
|
|
|
|
func (p *QScopedValueRollback) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QScopedValueRollback) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQScopedValueRollback(ptr QScopedValueRollback_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QScopedValueRollback_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQScopedValueRollbackFromPointer(ptr unsafe.Pointer) *QScopedValueRollback {
|
|
var n = new(QScopedValueRollback)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQScopedValueRollbackFromPointer(ptr unsafe.Pointer) *QScopedValueRollback {
|
|
var n = NewQScopedValueRollbackFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QSemaphore struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSemaphore_ITF interface {
|
|
QSemaphore_PTR() *QSemaphore
|
|
}
|
|
|
|
func (p *QSemaphore) QSemaphore_PTR() *QSemaphore {
|
|
return p
|
|
}
|
|
|
|
func (p *QSemaphore) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSemaphore) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQSemaphore(ptr QSemaphore_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSemaphore_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSemaphoreFromPointer(ptr unsafe.Pointer) *QSemaphore {
|
|
var n = new(QSemaphore)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSemaphoreFromPointer(ptr unsafe.Pointer) *QSemaphore {
|
|
var n = NewQSemaphoreFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQSemaphore(n int) *QSemaphore {
|
|
defer qt.Recovering("QSemaphore::QSemaphore")
|
|
|
|
return newQSemaphoreFromPointer(C.QSemaphore_NewQSemaphore(C.int(n)))
|
|
}
|
|
|
|
func (ptr *QSemaphore) Acquire(n int) {
|
|
defer qt.Recovering("QSemaphore::acquire")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSemaphore_Acquire(ptr.Pointer(), C.int(n))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSemaphore) Available() int {
|
|
defer qt.Recovering("QSemaphore::available")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSemaphore_Available(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSemaphore) Release(n int) {
|
|
defer qt.Recovering("QSemaphore::release")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSemaphore_Release(ptr.Pointer(), C.int(n))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSemaphore) TryAcquire(n int) bool {
|
|
defer qt.Recovering("QSemaphore::tryAcquire")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSemaphore_TryAcquire(ptr.Pointer(), C.int(n)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSemaphore) TryAcquire2(n int, timeout int) bool {
|
|
defer qt.Recovering("QSemaphore::tryAcquire")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSemaphore_TryAcquire2(ptr.Pointer(), C.int(n), C.int(timeout)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSemaphore) DestroyQSemaphore() {
|
|
defer qt.Recovering("QSemaphore::~QSemaphore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSemaphore_DestroyQSemaphore(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QSequentialAnimationGroup struct {
|
|
QAnimationGroup
|
|
}
|
|
|
|
type QSequentialAnimationGroup_ITF interface {
|
|
QAnimationGroup_ITF
|
|
QSequentialAnimationGroup_PTR() *QSequentialAnimationGroup
|
|
}
|
|
|
|
func (p *QSequentialAnimationGroup) QSequentialAnimationGroup_PTR() *QSequentialAnimationGroup {
|
|
return p
|
|
}
|
|
|
|
func (p *QSequentialAnimationGroup) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAnimationGroup_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSequentialAnimationGroup) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAnimationGroup_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQSequentialAnimationGroup(ptr QSequentialAnimationGroup_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSequentialAnimationGroup_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSequentialAnimationGroupFromPointer(ptr unsafe.Pointer) *QSequentialAnimationGroup {
|
|
var n = new(QSequentialAnimationGroup)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSequentialAnimationGroupFromPointer(ptr unsafe.Pointer) *QSequentialAnimationGroup {
|
|
var n = NewQSequentialAnimationGroupFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QSequentialAnimationGroup_") {
|
|
n.SetObjectName("QSequentialAnimationGroup_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) CurrentAnimation() *QAbstractAnimation {
|
|
defer qt.Recovering("QSequentialAnimationGroup::currentAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractAnimationFromPointer(C.QSequentialAnimationGroup_CurrentAnimation(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSequentialAnimationGroup(parent QObject_ITF) *QSequentialAnimationGroup {
|
|
defer qt.Recovering("QSequentialAnimationGroup::QSequentialAnimationGroup")
|
|
|
|
return newQSequentialAnimationGroupFromPointer(C.QSequentialAnimationGroup_NewQSequentialAnimationGroup(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) AddPause(msecs int) *QPauseAnimation {
|
|
defer qt.Recovering("QSequentialAnimationGroup::addPause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPauseAnimationFromPointer(C.QSequentialAnimationGroup_AddPause(ptr.Pointer(), C.int(msecs)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_CurrentAnimationChanged
|
|
func callbackQSequentialAnimationGroup_CurrentAnimationChanged(ptr unsafe.Pointer, ptrName *C.char, current unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::currentAnimationChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "currentAnimationChanged"); signal != nil {
|
|
signal.(func(*QAbstractAnimation))(NewQAbstractAnimationFromPointer(current))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectCurrentAnimationChanged(f func(current *QAbstractAnimation)) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::currentAnimationChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_ConnectCurrentAnimationChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "currentAnimationChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectCurrentAnimationChanged() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::currentAnimationChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_DisconnectCurrentAnimationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "currentAnimationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) CurrentAnimationChanged(current QAbstractAnimation_ITF) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::currentAnimationChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_CurrentAnimationChanged(ptr.Pointer(), PointerFromQAbstractAnimation(current))
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_Duration
|
|
func callbackQSequentialAnimationGroup_Duration(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::duration")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "duration"); signal != nil {
|
|
return C.int(signal.(func() int)())
|
|
}
|
|
|
|
return C.int(NewQSequentialAnimationGroupFromPointer(ptr).DurationDefault())
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectDuration(f func() int) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "duration", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectDuration() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) Duration() int {
|
|
defer qt.Recovering("QSequentialAnimationGroup::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSequentialAnimationGroup_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DurationDefault() int {
|
|
defer qt.Recovering("QSequentialAnimationGroup::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSequentialAnimationGroup_DurationDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_Event
|
|
func callbackQSequentialAnimationGroup_Event(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSequentialAnimationGroupFromPointer(ptr).EventDefault(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectEvent(f func(event *QEvent) bool) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) Event(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSequentialAnimationGroup::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSequentialAnimationGroup_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) EventDefault(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSequentialAnimationGroup::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSequentialAnimationGroup_EventDefault(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) InsertPause(index int, msecs int) *QPauseAnimation {
|
|
defer qt.Recovering("QSequentialAnimationGroup::insertPause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPauseAnimationFromPointer(C.QSequentialAnimationGroup_InsertPause(ptr.Pointer(), C.int(index), C.int(msecs)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_UpdateCurrentTime
|
|
func callbackQSequentialAnimationGroup_UpdateCurrentTime(ptr unsafe.Pointer, ptrName *C.char, currentTime C.int) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::updateCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(currentTime))
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).UpdateCurrentTimeDefault(int(currentTime))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectUpdateCurrentTime(f func(currentTime int)) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectUpdateCurrentTime() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) UpdateCurrentTime(currentTime int) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_UpdateCurrentTime(ptr.Pointer(), C.int(currentTime))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) UpdateCurrentTimeDefault(currentTime int) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(currentTime))
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_UpdateDirection
|
|
func callbackQSequentialAnimationGroup_UpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::updateDirection")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
|
|
signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectUpdateDirection() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateDirection")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) UpdateDirection(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_UpdateDirection(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_UpdateState
|
|
func callbackQSequentialAnimationGroup_UpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::updateState")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
|
|
signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectUpdateState() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateState")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DestroyQSequentialAnimationGroup() {
|
|
defer qt.Recovering("QSequentialAnimationGroup::~QSequentialAnimationGroup")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSequentialAnimationGroup_DestroyQSequentialAnimationGroup(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_SetCurrentTime
|
|
func callbackQSequentialAnimationGroup_SetCurrentTime(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::setCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(msecs))
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).SetCurrentTimeDefault(int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectSetCurrentTime(f func(msecs int)) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectSetCurrentTime() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) SetCurrentTime(msecs int) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_SetCurrentTime(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) SetCurrentTimeDefault(msecs int) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_SetCurrentTimeDefault(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_Pause
|
|
func callbackQSequentialAnimationGroup_Pause(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::pause")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pause"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).PauseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectPause(f func()) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pause", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectPause() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pause")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) Pause() {
|
|
defer qt.Recovering("QSequentialAnimationGroup::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_Pause(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) PauseDefault() {
|
|
defer qt.Recovering("QSequentialAnimationGroup::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_PauseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_Resume
|
|
func callbackQSequentialAnimationGroup_Resume(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::resume")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resume"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).ResumeDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectResume(f func()) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resume", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectResume() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) Resume() {
|
|
defer qt.Recovering("QSequentialAnimationGroup::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_Resume(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ResumeDefault() {
|
|
defer qt.Recovering("QSequentialAnimationGroup::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_ResumeDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_SetPaused
|
|
func callbackQSequentialAnimationGroup_SetPaused(ptr unsafe.Pointer, ptrName *C.char, paused C.int) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::setPaused")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setPaused"); signal != nil {
|
|
signal.(func(bool))(int(paused) != 0)
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).SetPausedDefault(int(paused) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectSetPaused(f func(paused bool)) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setPaused", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectSetPaused() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setPaused")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) SetPaused(paused bool) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_SetPaused(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) SetPausedDefault(paused bool) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_SetPausedDefault(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_Start
|
|
func callbackQSequentialAnimationGroup_Start(ptr unsafe.Pointer, ptrName *C.char, policy C.int) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::start")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "start"); signal != nil {
|
|
signal.(func(QAbstractAnimation__DeletionPolicy))(QAbstractAnimation__DeletionPolicy(policy))
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).StartDefault(QAbstractAnimation__DeletionPolicy(policy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectStart(f func(policy QAbstractAnimation__DeletionPolicy)) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "start", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectStart() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) Start(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_Start(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) StartDefault(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_StartDefault(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_Stop
|
|
func callbackQSequentialAnimationGroup_Stop(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::stop")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectStop(f func()) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "stop", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectStop() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) Stop() {
|
|
defer qt.Recovering("QSequentialAnimationGroup::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) StopDefault() {
|
|
defer qt.Recovering("QSequentialAnimationGroup::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_TimerEvent
|
|
func callbackQSequentialAnimationGroup_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_ChildEvent
|
|
func callbackQSequentialAnimationGroup_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_ConnectNotify
|
|
func callbackQSequentialAnimationGroup_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_CustomEvent
|
|
func callbackQSequentialAnimationGroup_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_DeleteLater
|
|
func callbackQSequentialAnimationGroup_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DeleteLater() {
|
|
defer qt.Recovering("QSequentialAnimationGroup::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSequentialAnimationGroup_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DeleteLaterDefault() {
|
|
defer qt.Recovering("QSequentialAnimationGroup::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSequentialAnimationGroup_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_DisconnectNotify
|
|
func callbackQSequentialAnimationGroup_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSequentialAnimationGroupFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSequentialAnimationGroup::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSequentialAnimationGroup_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_EventFilter
|
|
func callbackQSequentialAnimationGroup_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSequentialAnimationGroupFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSequentialAnimationGroup::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSequentialAnimationGroup_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSequentialAnimationGroup::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSequentialAnimationGroup_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSequentialAnimationGroup_MetaObject
|
|
func callbackQSequentialAnimationGroup_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSequentialAnimationGroup::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQSequentialAnimationGroupFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QSequentialAnimationGroup::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QSequentialAnimationGroup::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QSequentialAnimationGroup::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSequentialAnimationGroup_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSequentialAnimationGroup) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QSequentialAnimationGroup::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSequentialAnimationGroup_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QSequentialIterable struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSequentialIterable_ITF interface {
|
|
QSequentialIterable_PTR() *QSequentialIterable
|
|
}
|
|
|
|
func (p *QSequentialIterable) QSequentialIterable_PTR() *QSequentialIterable {
|
|
return p
|
|
}
|
|
|
|
func (p *QSequentialIterable) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSequentialIterable) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQSequentialIterable(ptr QSequentialIterable_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSequentialIterable_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSequentialIterableFromPointer(ptr unsafe.Pointer) *QSequentialIterable {
|
|
var n = new(QSequentialIterable)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSequentialIterableFromPointer(ptr unsafe.Pointer) *QSequentialIterable {
|
|
var n = NewQSequentialIterableFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QSequentialIterable) At(idx int) *QVariant {
|
|
defer qt.Recovering("QSequentialIterable::at")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QSequentialIterable_At(ptr.Pointer(), C.int(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSequentialIterable) CanReverseIterate() bool {
|
|
defer qt.Recovering("QSequentialIterable::canReverseIterate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSequentialIterable_CanReverseIterate(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSequentialIterable) Size() int {
|
|
defer qt.Recovering("QSequentialIterable::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSequentialIterable_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QSet struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSet_ITF interface {
|
|
QSet_PTR() *QSet
|
|
}
|
|
|
|
func (p *QSet) QSet_PTR() *QSet {
|
|
return p
|
|
}
|
|
|
|
func (p *QSet) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSet) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQSet(ptr QSet_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSet_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSetFromPointer(ptr unsafe.Pointer) *QSet {
|
|
var n = new(QSet)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSetFromPointer(ptr unsafe.Pointer) *QSet {
|
|
var n = NewQSetFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QSetIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSetIterator_ITF interface {
|
|
QSetIterator_PTR() *QSetIterator
|
|
}
|
|
|
|
func (p *QSetIterator) QSetIterator_PTR() *QSetIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QSetIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSetIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQSetIterator(ptr QSetIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSetIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSetIteratorFromPointer(ptr unsafe.Pointer) *QSetIterator {
|
|
var n = new(QSetIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSetIteratorFromPointer(ptr unsafe.Pointer) *QSetIterator {
|
|
var n = NewQSetIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QSettings::Format
|
|
type QSettings__Format int64
|
|
|
|
const (
|
|
QSettings__NativeFormat = QSettings__Format(0)
|
|
QSettings__IniFormat = QSettings__Format(1)
|
|
QSettings__InvalidFormat = QSettings__Format(16)
|
|
QSettings__CustomFormat1 = QSettings__Format(17)
|
|
QSettings__CustomFormat2 = QSettings__Format(18)
|
|
QSettings__CustomFormat3 = QSettings__Format(19)
|
|
QSettings__CustomFormat4 = QSettings__Format(20)
|
|
QSettings__CustomFormat5 = QSettings__Format(21)
|
|
QSettings__CustomFormat6 = QSettings__Format(22)
|
|
QSettings__CustomFormat7 = QSettings__Format(23)
|
|
QSettings__CustomFormat8 = QSettings__Format(24)
|
|
QSettings__CustomFormat9 = QSettings__Format(25)
|
|
QSettings__CustomFormat10 = QSettings__Format(26)
|
|
QSettings__CustomFormat11 = QSettings__Format(27)
|
|
QSettings__CustomFormat12 = QSettings__Format(28)
|
|
QSettings__CustomFormat13 = QSettings__Format(29)
|
|
QSettings__CustomFormat14 = QSettings__Format(30)
|
|
QSettings__CustomFormat15 = QSettings__Format(31)
|
|
QSettings__CustomFormat16 = QSettings__Format(32)
|
|
)
|
|
|
|
//QSettings::Scope
|
|
type QSettings__Scope int64
|
|
|
|
const (
|
|
QSettings__UserScope = QSettings__Scope(0)
|
|
QSettings__SystemScope = QSettings__Scope(1)
|
|
)
|
|
|
|
//QSettings::Status
|
|
type QSettings__Status int64
|
|
|
|
const (
|
|
QSettings__NoError = QSettings__Status(0)
|
|
QSettings__AccessError = QSettings__Status(1)
|
|
QSettings__FormatError = QSettings__Status(2)
|
|
)
|
|
|
|
type QSettings struct {
|
|
QObject
|
|
}
|
|
|
|
type QSettings_ITF interface {
|
|
QObject_ITF
|
|
QSettings_PTR() *QSettings
|
|
}
|
|
|
|
func (p *QSettings) QSettings_PTR() *QSettings {
|
|
return p
|
|
}
|
|
|
|
func (p *QSettings) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSettings) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQSettings(ptr QSettings_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSettings_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSettingsFromPointer(ptr unsafe.Pointer) *QSettings {
|
|
var n = new(QSettings)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSettingsFromPointer(ptr unsafe.Pointer) *QSettings {
|
|
var n = NewQSettingsFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QSettings_") {
|
|
n.SetObjectName("QSettings_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQSettings3(format QSettings__Format, scope QSettings__Scope, organization string, application string, parent QObject_ITF) *QSettings {
|
|
defer qt.Recovering("QSettings::QSettings")
|
|
|
|
return newQSettingsFromPointer(C.QSettings_NewQSettings3(C.int(format), C.int(scope), C.CString(organization), C.CString(application), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQSettings5(parent QObject_ITF) *QSettings {
|
|
defer qt.Recovering("QSettings::QSettings")
|
|
|
|
return newQSettingsFromPointer(C.QSettings_NewQSettings5(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQSettings2(scope QSettings__Scope, organization string, application string, parent QObject_ITF) *QSettings {
|
|
defer qt.Recovering("QSettings::QSettings")
|
|
|
|
return newQSettingsFromPointer(C.QSettings_NewQSettings2(C.int(scope), C.CString(organization), C.CString(application), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQSettings4(fileName string, format QSettings__Format, parent QObject_ITF) *QSettings {
|
|
defer qt.Recovering("QSettings::QSettings")
|
|
|
|
return newQSettingsFromPointer(C.QSettings_NewQSettings4(C.CString(fileName), C.int(format), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQSettings(organization string, application string, parent QObject_ITF) *QSettings {
|
|
defer qt.Recovering("QSettings::QSettings")
|
|
|
|
return newQSettingsFromPointer(C.QSettings_NewQSettings(C.CString(organization), C.CString(application), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QSettings) AllKeys() []string {
|
|
defer qt.Recovering("QSettings::allKeys")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QSettings_AllKeys(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QSettings) ApplicationName() string {
|
|
defer qt.Recovering("QSettings::applicationName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QSettings_ApplicationName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QSettings) BeginGroup(prefix string) {
|
|
defer qt.Recovering("QSettings::beginGroup")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_BeginGroup(ptr.Pointer(), C.CString(prefix))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) BeginReadArray(prefix string) int {
|
|
defer qt.Recovering("QSettings::beginReadArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSettings_BeginReadArray(ptr.Pointer(), C.CString(prefix)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSettings) BeginWriteArray(prefix string, size int) {
|
|
defer qt.Recovering("QSettings::beginWriteArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_BeginWriteArray(ptr.Pointer(), C.CString(prefix), C.int(size))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) ChildGroups() []string {
|
|
defer qt.Recovering("QSettings::childGroups")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QSettings_ChildGroups(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QSettings) ChildKeys() []string {
|
|
defer qt.Recovering("QSettings::childKeys")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QSettings_ChildKeys(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QSettings) Clear() {
|
|
defer qt.Recovering("QSettings::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) Contains(key string) bool {
|
|
defer qt.Recovering("QSettings::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSettings_Contains(ptr.Pointer(), C.CString(key)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QSettings_DefaultFormat() QSettings__Format {
|
|
defer qt.Recovering("QSettings::defaultFormat")
|
|
|
|
return QSettings__Format(C.QSettings_QSettings_DefaultFormat())
|
|
}
|
|
|
|
func (ptr *QSettings) DefaultFormat() QSettings__Format {
|
|
defer qt.Recovering("QSettings::defaultFormat")
|
|
|
|
return QSettings__Format(C.QSettings_QSettings_DefaultFormat())
|
|
}
|
|
|
|
func (ptr *QSettings) EndArray() {
|
|
defer qt.Recovering("QSettings::endArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_EndArray(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) EndGroup() {
|
|
defer qt.Recovering("QSettings::endGroup")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_EndGroup(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSettings_Event
|
|
func callbackQSettings_Event(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSettings::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSettingsFromPointer(ptr).EventDefault(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QSettings) ConnectEvent(f func(event *QEvent) bool) {
|
|
defer qt.Recovering("connect QSettings::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QSettings::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) Event(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSettings::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSettings_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSettings) EventDefault(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSettings::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSettings_EventDefault(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSettings) FallbacksEnabled() bool {
|
|
defer qt.Recovering("QSettings::fallbacksEnabled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSettings_FallbacksEnabled(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSettings) FileName() string {
|
|
defer qt.Recovering("QSettings::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QSettings_FileName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QSettings) Format() QSettings__Format {
|
|
defer qt.Recovering("QSettings::format")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QSettings__Format(C.QSettings_Format(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSettings) Group() string {
|
|
defer qt.Recovering("QSettings::group")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QSettings_Group(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QSettings) IniCodec() *QTextCodec {
|
|
defer qt.Recovering("QSettings::iniCodec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQTextCodecFromPointer(C.QSettings_IniCodec(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSettings) IsWritable() bool {
|
|
defer qt.Recovering("QSettings::isWritable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSettings_IsWritable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSettings) OrganizationName() string {
|
|
defer qt.Recovering("QSettings::organizationName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QSettings_OrganizationName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QSettings) Remove(key string) {
|
|
defer qt.Recovering("QSettings::remove")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_Remove(ptr.Pointer(), C.CString(key))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) Scope() QSettings__Scope {
|
|
defer qt.Recovering("QSettings::scope")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QSettings__Scope(C.QSettings_Scope(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSettings) SetArrayIndex(i int) {
|
|
defer qt.Recovering("QSettings::setArrayIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_SetArrayIndex(ptr.Pointer(), C.int(i))
|
|
}
|
|
}
|
|
|
|
func QSettings_SetDefaultFormat(format QSettings__Format) {
|
|
defer qt.Recovering("QSettings::setDefaultFormat")
|
|
|
|
C.QSettings_QSettings_SetDefaultFormat(C.int(format))
|
|
}
|
|
|
|
func (ptr *QSettings) SetDefaultFormat(format QSettings__Format) {
|
|
defer qt.Recovering("QSettings::setDefaultFormat")
|
|
|
|
C.QSettings_QSettings_SetDefaultFormat(C.int(format))
|
|
}
|
|
|
|
func (ptr *QSettings) SetFallbacksEnabled(b bool) {
|
|
defer qt.Recovering("QSettings::setFallbacksEnabled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_SetFallbacksEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(b)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) SetIniCodec(codec QTextCodec_ITF) {
|
|
defer qt.Recovering("QSettings::setIniCodec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_SetIniCodec(ptr.Pointer(), PointerFromQTextCodec(codec))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) SetIniCodec2(codecName string) {
|
|
defer qt.Recovering("QSettings::setIniCodec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_SetIniCodec2(ptr.Pointer(), C.CString(codecName))
|
|
}
|
|
}
|
|
|
|
func QSettings_SetPath(format QSettings__Format, scope QSettings__Scope, path string) {
|
|
defer qt.Recovering("QSettings::setPath")
|
|
|
|
C.QSettings_QSettings_SetPath(C.int(format), C.int(scope), C.CString(path))
|
|
}
|
|
|
|
func (ptr *QSettings) SetPath(format QSettings__Format, scope QSettings__Scope, path string) {
|
|
defer qt.Recovering("QSettings::setPath")
|
|
|
|
C.QSettings_QSettings_SetPath(C.int(format), C.int(scope), C.CString(path))
|
|
}
|
|
|
|
func (ptr *QSettings) SetValue(key string, value QVariant_ITF) {
|
|
defer qt.Recovering("QSettings::setValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_SetValue(ptr.Pointer(), C.CString(key), PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) Status() QSettings__Status {
|
|
defer qt.Recovering("QSettings::status")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QSettings__Status(C.QSettings_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSettings) Sync() {
|
|
defer qt.Recovering("QSettings::sync")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_Sync(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) Value(key string, defaultValue QVariant_ITF) *QVariant {
|
|
defer qt.Recovering("QSettings::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QSettings_Value(ptr.Pointer(), C.CString(key), PointerFromQVariant(defaultValue)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSettings) DestroyQSettings() {
|
|
defer qt.Recovering("QSettings::~QSettings")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSettings_DestroyQSettings(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSettings_TimerEvent
|
|
func callbackQSettings_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSettings::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQSettingsFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QSettings::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QSettings::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSettings::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSettings::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSettings_ChildEvent
|
|
func callbackQSettings_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSettings::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQSettingsFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QSettings::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QSettings::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSettings::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSettings::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSettings_ConnectNotify
|
|
func callbackQSettings_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSettings::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSettingsFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSettings::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QSettings::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSettings::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSettings::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSettings_CustomEvent
|
|
func callbackQSettings_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSettings::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQSettingsFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QSettings::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QSettings::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QSettings::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QSettings::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSettings_DeleteLater
|
|
func callbackQSettings_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSettings::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSettingsFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QSettings::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QSettings::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DeleteLater() {
|
|
defer qt.Recovering("QSettings::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSettings_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DeleteLaterDefault() {
|
|
defer qt.Recovering("QSettings::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSettings_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSettings_DisconnectNotify
|
|
func callbackQSettings_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSettings::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSettingsFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSettings::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QSettings::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSettings::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSettings::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSettings_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSettings_EventFilter
|
|
func callbackQSettings_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSettings::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSettingsFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QSettings) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QSettings::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QSettings::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSettings::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSettings_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSettings) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSettings::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSettings_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSettings_MetaObject
|
|
func callbackQSettings_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSettings::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQSettingsFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QSettings) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QSettings::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QSettings::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSettings) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QSettings::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSettings_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSettings) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QSettings::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSettings_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QSharedData struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSharedData_ITF interface {
|
|
QSharedData_PTR() *QSharedData
|
|
}
|
|
|
|
func (p *QSharedData) QSharedData_PTR() *QSharedData {
|
|
return p
|
|
}
|
|
|
|
func (p *QSharedData) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSharedData) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQSharedData(ptr QSharedData_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSharedData_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSharedDataFromPointer(ptr unsafe.Pointer) *QSharedData {
|
|
var n = new(QSharedData)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSharedDataFromPointer(ptr unsafe.Pointer) *QSharedData {
|
|
var n = NewQSharedDataFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQSharedData() *QSharedData {
|
|
defer qt.Recovering("QSharedData::QSharedData")
|
|
|
|
return newQSharedDataFromPointer(C.QSharedData_NewQSharedData())
|
|
}
|
|
|
|
func NewQSharedData2(other QSharedData_ITF) *QSharedData {
|
|
defer qt.Recovering("QSharedData::QSharedData")
|
|
|
|
return newQSharedDataFromPointer(C.QSharedData_NewQSharedData2(PointerFromQSharedData(other)))
|
|
}
|
|
|
|
type QSharedDataPointer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSharedDataPointer_ITF interface {
|
|
QSharedDataPointer_PTR() *QSharedDataPointer
|
|
}
|
|
|
|
func (p *QSharedDataPointer) QSharedDataPointer_PTR() *QSharedDataPointer {
|
|
return p
|
|
}
|
|
|
|
func (p *QSharedDataPointer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSharedDataPointer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQSharedDataPointer(ptr QSharedDataPointer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSharedDataPointer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSharedDataPointerFromPointer(ptr unsafe.Pointer) *QSharedDataPointer {
|
|
var n = new(QSharedDataPointer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSharedDataPointerFromPointer(ptr unsafe.Pointer) *QSharedDataPointer {
|
|
var n = NewQSharedDataPointerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QSharedMemory::AccessMode
|
|
type QSharedMemory__AccessMode int64
|
|
|
|
const (
|
|
QSharedMemory__ReadOnly = QSharedMemory__AccessMode(0)
|
|
QSharedMemory__ReadWrite = QSharedMemory__AccessMode(1)
|
|
)
|
|
|
|
//QSharedMemory::SharedMemoryError
|
|
type QSharedMemory__SharedMemoryError int64
|
|
|
|
const (
|
|
QSharedMemory__NoError = QSharedMemory__SharedMemoryError(0)
|
|
QSharedMemory__PermissionDenied = QSharedMemory__SharedMemoryError(1)
|
|
QSharedMemory__InvalidSize = QSharedMemory__SharedMemoryError(2)
|
|
QSharedMemory__KeyError = QSharedMemory__SharedMemoryError(3)
|
|
QSharedMemory__AlreadyExists = QSharedMemory__SharedMemoryError(4)
|
|
QSharedMemory__NotFound = QSharedMemory__SharedMemoryError(5)
|
|
QSharedMemory__LockError = QSharedMemory__SharedMemoryError(6)
|
|
QSharedMemory__OutOfResources = QSharedMemory__SharedMemoryError(7)
|
|
QSharedMemory__UnknownError = QSharedMemory__SharedMemoryError(8)
|
|
)
|
|
|
|
type QSharedMemory struct {
|
|
QObject
|
|
}
|
|
|
|
type QSharedMemory_ITF interface {
|
|
QObject_ITF
|
|
QSharedMemory_PTR() *QSharedMemory
|
|
}
|
|
|
|
func (p *QSharedMemory) QSharedMemory_PTR() *QSharedMemory {
|
|
return p
|
|
}
|
|
|
|
func (p *QSharedMemory) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSharedMemory) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQSharedMemory(ptr QSharedMemory_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSharedMemory_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSharedMemoryFromPointer(ptr unsafe.Pointer) *QSharedMemory {
|
|
var n = new(QSharedMemory)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSharedMemoryFromPointer(ptr unsafe.Pointer) *QSharedMemory {
|
|
var n = NewQSharedMemoryFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QSharedMemory_") {
|
|
n.SetObjectName("QSharedMemory_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQSharedMemory2(parent QObject_ITF) *QSharedMemory {
|
|
defer qt.Recovering("QSharedMemory::QSharedMemory")
|
|
|
|
return newQSharedMemoryFromPointer(C.QSharedMemory_NewQSharedMemory2(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQSharedMemory(key string, parent QObject_ITF) *QSharedMemory {
|
|
defer qt.Recovering("QSharedMemory::QSharedMemory")
|
|
|
|
return newQSharedMemoryFromPointer(C.QSharedMemory_NewQSharedMemory(C.CString(key), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QSharedMemory) Attach(mode QSharedMemory__AccessMode) bool {
|
|
defer qt.Recovering("QSharedMemory::attach")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSharedMemory_Attach(ptr.Pointer(), C.int(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ConstData() unsafe.Pointer {
|
|
defer qt.Recovering("QSharedMemory::constData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QSharedMemory_ConstData(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSharedMemory) Create(size int, mode QSharedMemory__AccessMode) bool {
|
|
defer qt.Recovering("QSharedMemory::create")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSharedMemory_Create(ptr.Pointer(), C.int(size), C.int(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSharedMemory) Data() unsafe.Pointer {
|
|
defer qt.Recovering("QSharedMemory::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QSharedMemory_Data(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSharedMemory) Data2() unsafe.Pointer {
|
|
defer qt.Recovering("QSharedMemory::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QSharedMemory_Data2(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSharedMemory) Detach() bool {
|
|
defer qt.Recovering("QSharedMemory::detach")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSharedMemory_Detach(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSharedMemory) Error() QSharedMemory__SharedMemoryError {
|
|
defer qt.Recovering("QSharedMemory::error")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QSharedMemory__SharedMemoryError(C.QSharedMemory_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ErrorString() string {
|
|
defer qt.Recovering("QSharedMemory::errorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QSharedMemory_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QSharedMemory) IsAttached() bool {
|
|
defer qt.Recovering("QSharedMemory::isAttached")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSharedMemory_IsAttached(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSharedMemory) Key() string {
|
|
defer qt.Recovering("QSharedMemory::key")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QSharedMemory_Key(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QSharedMemory) Lock() bool {
|
|
defer qt.Recovering("QSharedMemory::lock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSharedMemory_Lock(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSharedMemory) NativeKey() string {
|
|
defer qt.Recovering("QSharedMemory::nativeKey")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QSharedMemory_NativeKey(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QSharedMemory) SetKey(key string) {
|
|
defer qt.Recovering("QSharedMemory::setKey")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_SetKey(ptr.Pointer(), C.CString(key))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) SetNativeKey(key string) {
|
|
defer qt.Recovering("QSharedMemory::setNativeKey")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_SetNativeKey(ptr.Pointer(), C.CString(key))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) Size() int {
|
|
defer qt.Recovering("QSharedMemory::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSharedMemory_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSharedMemory) Unlock() bool {
|
|
defer qt.Recovering("QSharedMemory::unlock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSharedMemory_Unlock(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DestroyQSharedMemory() {
|
|
defer qt.Recovering("QSharedMemory::~QSharedMemory")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_DestroyQSharedMemory(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSharedMemory_TimerEvent
|
|
func callbackQSharedMemory_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSharedMemory::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQSharedMemoryFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QSharedMemory::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QSharedMemory::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSharedMemory::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSharedMemory::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSharedMemory_ChildEvent
|
|
func callbackQSharedMemory_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSharedMemory::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQSharedMemoryFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QSharedMemory::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QSharedMemory::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSharedMemory::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSharedMemory::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSharedMemory_ConnectNotify
|
|
func callbackQSharedMemory_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSharedMemory::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSharedMemoryFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSharedMemory::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QSharedMemory::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSharedMemory::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSharedMemory::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSharedMemory_CustomEvent
|
|
func callbackQSharedMemory_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSharedMemory::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQSharedMemoryFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QSharedMemory::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QSharedMemory::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QSharedMemory::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QSharedMemory::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSharedMemory_DeleteLater
|
|
func callbackQSharedMemory_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSharedMemory::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSharedMemoryFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QSharedMemory::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QSharedMemory::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DeleteLater() {
|
|
defer qt.Recovering("QSharedMemory::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DeleteLaterDefault() {
|
|
defer qt.Recovering("QSharedMemory::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSharedMemory_DisconnectNotify
|
|
func callbackQSharedMemory_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSharedMemory::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSharedMemoryFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSharedMemory::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QSharedMemory::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSharedMemory::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSharedMemory::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSharedMemory_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSharedMemory_Event
|
|
func callbackQSharedMemory_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSharedMemory::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSharedMemoryFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QSharedMemory::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QSharedMemory::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QSharedMemory::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSharedMemory_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSharedMemory) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QSharedMemory::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSharedMemory_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSharedMemory_EventFilter
|
|
func callbackQSharedMemory_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSharedMemory::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSharedMemoryFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QSharedMemory::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QSharedMemory::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSharedMemory::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSharedMemory_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSharedMemory) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSharedMemory::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSharedMemory_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSharedMemory_MetaObject
|
|
func callbackQSharedMemory_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSharedMemory::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQSharedMemoryFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QSharedMemory) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QSharedMemory::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QSharedMemory::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSharedMemory) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QSharedMemory::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSharedMemory_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSharedMemory) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QSharedMemory::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSharedMemory_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QSharedPointer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSharedPointer_ITF interface {
|
|
QSharedPointer_PTR() *QSharedPointer
|
|
}
|
|
|
|
func (p *QSharedPointer) QSharedPointer_PTR() *QSharedPointer {
|
|
return p
|
|
}
|
|
|
|
func (p *QSharedPointer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSharedPointer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQSharedPointer(ptr QSharedPointer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSharedPointer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSharedPointerFromPointer(ptr unsafe.Pointer) *QSharedPointer {
|
|
var n = new(QSharedPointer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSharedPointerFromPointer(ptr unsafe.Pointer) *QSharedPointer {
|
|
var n = NewQSharedPointerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QSignalBlocker struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSignalBlocker_ITF interface {
|
|
QSignalBlocker_PTR() *QSignalBlocker
|
|
}
|
|
|
|
func (p *QSignalBlocker) QSignalBlocker_PTR() *QSignalBlocker {
|
|
return p
|
|
}
|
|
|
|
func (p *QSignalBlocker) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSignalBlocker) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQSignalBlocker(ptr QSignalBlocker_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSignalBlocker_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSignalBlockerFromPointer(ptr unsafe.Pointer) *QSignalBlocker {
|
|
var n = new(QSignalBlocker)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSignalBlockerFromPointer(ptr unsafe.Pointer) *QSignalBlocker {
|
|
var n = NewQSignalBlockerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQSignalBlocker2(object QObject_ITF) *QSignalBlocker {
|
|
defer qt.Recovering("QSignalBlocker::QSignalBlocker")
|
|
|
|
return newQSignalBlockerFromPointer(C.QSignalBlocker_NewQSignalBlocker2(PointerFromQObject(object)))
|
|
}
|
|
|
|
func NewQSignalBlocker(object QObject_ITF) *QSignalBlocker {
|
|
defer qt.Recovering("QSignalBlocker::QSignalBlocker")
|
|
|
|
return newQSignalBlockerFromPointer(C.QSignalBlocker_NewQSignalBlocker(PointerFromQObject(object)))
|
|
}
|
|
|
|
func (ptr *QSignalBlocker) Reblock() {
|
|
defer qt.Recovering("QSignalBlocker::reblock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalBlocker_Reblock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalBlocker) Unblock() {
|
|
defer qt.Recovering("QSignalBlocker::unblock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalBlocker_Unblock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalBlocker) DestroyQSignalBlocker() {
|
|
defer qt.Recovering("QSignalBlocker::~QSignalBlocker")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalBlocker_DestroyQSignalBlocker(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QSignalMapper struct {
|
|
QObject
|
|
}
|
|
|
|
type QSignalMapper_ITF interface {
|
|
QObject_ITF
|
|
QSignalMapper_PTR() *QSignalMapper
|
|
}
|
|
|
|
func (p *QSignalMapper) QSignalMapper_PTR() *QSignalMapper {
|
|
return p
|
|
}
|
|
|
|
func (p *QSignalMapper) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSignalMapper) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQSignalMapper(ptr QSignalMapper_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSignalMapper_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSignalMapperFromPointer(ptr unsafe.Pointer) *QSignalMapper {
|
|
var n = new(QSignalMapper)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSignalMapperFromPointer(ptr unsafe.Pointer) *QSignalMapper {
|
|
var n = NewQSignalMapperFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QSignalMapper_") {
|
|
n.SetObjectName("QSignalMapper_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQSignalMapper(parent QObject_ITF) *QSignalMapper {
|
|
defer qt.Recovering("QSignalMapper::QSignalMapper")
|
|
|
|
return newQSignalMapperFromPointer(C.QSignalMapper_NewQSignalMapper(PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQSignalMapper_Map
|
|
func callbackQSignalMapper_Map(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSignalMapper::map")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "map"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectMap(f func()) {
|
|
defer qt.Recovering("connect QSignalMapper::map")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "map", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectMap() {
|
|
defer qt.Recovering("disconnect QSignalMapper::map")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "map")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) Map() {
|
|
defer qt.Recovering("QSignalMapper::map")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_Map(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalMapper_Map2
|
|
func callbackQSignalMapper_Map2(ptr unsafe.Pointer, ptrName *C.char, sender unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalMapper::map")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "map2"); signal != nil {
|
|
signal.(func(*QObject))(NewQObjectFromPointer(sender))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectMap2(f func(sender *QObject)) {
|
|
defer qt.Recovering("connect QSignalMapper::map")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "map2", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectMap2(sender QObject_ITF) {
|
|
defer qt.Recovering("disconnect QSignalMapper::map")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "map2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) Map2(sender QObject_ITF) {
|
|
defer qt.Recovering("QSignalMapper::map")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_Map2(ptr.Pointer(), PointerFromQObject(sender))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalMapper_Mapped4
|
|
func callbackQSignalMapper_Mapped4(ptr unsafe.Pointer, ptrName *C.char, object unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalMapper::mapped")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapped4"); signal != nil {
|
|
signal.(func(*QObject))(NewQObjectFromPointer(object))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectMapped4(f func(object *QObject)) {
|
|
defer qt.Recovering("connect QSignalMapper::mapped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_ConnectMapped4(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapped4", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectMapped4() {
|
|
defer qt.Recovering("disconnect QSignalMapper::mapped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_DisconnectMapped4(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapped4")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) Mapped4(object QObject_ITF) {
|
|
defer qt.Recovering("QSignalMapper::mapped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_Mapped4(ptr.Pointer(), PointerFromQObject(object))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalMapper_Mapped3
|
|
func callbackQSignalMapper_Mapped3(ptr unsafe.Pointer, ptrName *C.char, widget unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalMapper::mapped")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapped3"); signal != nil {
|
|
signal.(func(unsafe.Pointer))(unsafe.Pointer(widget))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectMapped3(f func(widget unsafe.Pointer)) {
|
|
defer qt.Recovering("connect QSignalMapper::mapped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_ConnectMapped3(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapped3", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectMapped3() {
|
|
defer qt.Recovering("disconnect QSignalMapper::mapped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_DisconnectMapped3(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapped3")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) Mapped3(widget unsafe.Pointer) {
|
|
defer qt.Recovering("QSignalMapper::mapped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_Mapped3(ptr.Pointer(), widget)
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalMapper_Mapped2
|
|
func callbackQSignalMapper_Mapped2(ptr unsafe.Pointer, ptrName *C.char, text *C.char) {
|
|
defer qt.Recovering("callback QSignalMapper::mapped")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapped2"); signal != nil {
|
|
signal.(func(string))(C.GoString(text))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectMapped2(f func(text string)) {
|
|
defer qt.Recovering("connect QSignalMapper::mapped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_ConnectMapped2(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapped2", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectMapped2() {
|
|
defer qt.Recovering("disconnect QSignalMapper::mapped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_DisconnectMapped2(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapped2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) Mapped2(text string) {
|
|
defer qt.Recovering("QSignalMapper::mapped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_Mapped2(ptr.Pointer(), C.CString(text))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalMapper_Mapped
|
|
func callbackQSignalMapper_Mapped(ptr unsafe.Pointer, ptrName *C.char, i C.int) {
|
|
defer qt.Recovering("callback QSignalMapper::mapped")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapped"); signal != nil {
|
|
signal.(func(int))(int(i))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectMapped(f func(i int)) {
|
|
defer qt.Recovering("connect QSignalMapper::mapped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_ConnectMapped(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapped", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectMapped() {
|
|
defer qt.Recovering("disconnect QSignalMapper::mapped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_DisconnectMapped(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapped")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) Mapped(i int) {
|
|
defer qt.Recovering("QSignalMapper::mapped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_Mapped(ptr.Pointer(), C.int(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) Mapping4(object QObject_ITF) *QObject {
|
|
defer qt.Recovering("QSignalMapper::mapping")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QSignalMapper_Mapping4(ptr.Pointer(), PointerFromQObject(object)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSignalMapper) Mapping3(widget unsafe.Pointer) *QObject {
|
|
defer qt.Recovering("QSignalMapper::mapping")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QSignalMapper_Mapping3(ptr.Pointer(), widget))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSignalMapper) Mapping2(id string) *QObject {
|
|
defer qt.Recovering("QSignalMapper::mapping")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QSignalMapper_Mapping2(ptr.Pointer(), C.CString(id)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSignalMapper) Mapping(id int) *QObject {
|
|
defer qt.Recovering("QSignalMapper::mapping")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QSignalMapper_Mapping(ptr.Pointer(), C.int(id)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSignalMapper) RemoveMappings(sender QObject_ITF) {
|
|
defer qt.Recovering("QSignalMapper::removeMappings")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_RemoveMappings(ptr.Pointer(), PointerFromQObject(sender))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) SetMapping4(sender QObject_ITF, object QObject_ITF) {
|
|
defer qt.Recovering("QSignalMapper::setMapping")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_SetMapping4(ptr.Pointer(), PointerFromQObject(sender), PointerFromQObject(object))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) SetMapping3(sender QObject_ITF, widget unsafe.Pointer) {
|
|
defer qt.Recovering("QSignalMapper::setMapping")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_SetMapping3(ptr.Pointer(), PointerFromQObject(sender), widget)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) SetMapping2(sender QObject_ITF, text string) {
|
|
defer qt.Recovering("QSignalMapper::setMapping")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_SetMapping2(ptr.Pointer(), PointerFromQObject(sender), C.CString(text))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) SetMapping(sender QObject_ITF, id int) {
|
|
defer qt.Recovering("QSignalMapper::setMapping")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_SetMapping(ptr.Pointer(), PointerFromQObject(sender), C.int(id))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DestroyQSignalMapper() {
|
|
defer qt.Recovering("QSignalMapper::~QSignalMapper")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSignalMapper_DestroyQSignalMapper(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalMapper_TimerEvent
|
|
func callbackQSignalMapper_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalMapper::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQSignalMapperFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QSignalMapper::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QSignalMapper::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSignalMapper::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSignalMapper::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalMapper_ChildEvent
|
|
func callbackQSignalMapper_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalMapper::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQSignalMapperFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QSignalMapper::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QSignalMapper::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSignalMapper::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSignalMapper::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalMapper_ConnectNotify
|
|
func callbackQSignalMapper_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalMapper::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSignalMapperFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSignalMapper::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QSignalMapper::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSignalMapper::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSignalMapper::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalMapper_CustomEvent
|
|
func callbackQSignalMapper_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalMapper::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQSignalMapperFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QSignalMapper::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QSignalMapper::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QSignalMapper::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QSignalMapper::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalMapper_DeleteLater
|
|
func callbackQSignalMapper_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSignalMapper::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSignalMapperFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QSignalMapper::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QSignalMapper::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DeleteLater() {
|
|
defer qt.Recovering("QSignalMapper::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSignalMapper_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DeleteLaterDefault() {
|
|
defer qt.Recovering("QSignalMapper::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSignalMapper_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalMapper_DisconnectNotify
|
|
func callbackQSignalMapper_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalMapper::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSignalMapperFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSignalMapper::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QSignalMapper::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSignalMapper::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSignalMapper::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalMapper_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalMapper_Event
|
|
func callbackQSignalMapper_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSignalMapper::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSignalMapperFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QSignalMapper::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QSignalMapper::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QSignalMapper::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSignalMapper_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSignalMapper) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QSignalMapper::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSignalMapper_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSignalMapper_EventFilter
|
|
func callbackQSignalMapper_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSignalMapper::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSignalMapperFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QSignalMapper::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QSignalMapper::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSignalMapper::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSignalMapper_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSignalMapper) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSignalMapper::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSignalMapper_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSignalMapper_MetaObject
|
|
func callbackQSignalMapper_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSignalMapper::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQSignalMapperFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QSignalMapper) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QSignalMapper::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QSignalMapper::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalMapper) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QSignalMapper::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSignalMapper_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSignalMapper) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QSignalMapper::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSignalMapper_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QSignalTransition struct {
|
|
QAbstractTransition
|
|
}
|
|
|
|
type QSignalTransition_ITF interface {
|
|
QAbstractTransition_ITF
|
|
QSignalTransition_PTR() *QSignalTransition
|
|
}
|
|
|
|
func (p *QSignalTransition) QSignalTransition_PTR() *QSignalTransition {
|
|
return p
|
|
}
|
|
|
|
func (p *QSignalTransition) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractTransition_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSignalTransition) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractTransition_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQSignalTransition(ptr QSignalTransition_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSignalTransition_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSignalTransitionFromPointer(ptr unsafe.Pointer) *QSignalTransition {
|
|
var n = new(QSignalTransition)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSignalTransitionFromPointer(ptr unsafe.Pointer) *QSignalTransition {
|
|
var n = NewQSignalTransitionFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QSignalTransition_") {
|
|
n.SetObjectName("QSignalTransition_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQSignalTransition(sourceState QState_ITF) *QSignalTransition {
|
|
defer qt.Recovering("QSignalTransition::QSignalTransition")
|
|
|
|
return newQSignalTransitionFromPointer(C.QSignalTransition_NewQSignalTransition(PointerFromQState(sourceState)))
|
|
}
|
|
|
|
func NewQSignalTransition2(sender QObject_ITF, sign string, sourceState QState_ITF) *QSignalTransition {
|
|
defer qt.Recovering("QSignalTransition::QSignalTransition")
|
|
|
|
return newQSignalTransitionFromPointer(C.QSignalTransition_NewQSignalTransition2(PointerFromQObject(sender), C.CString(sign), PointerFromQState(sourceState)))
|
|
}
|
|
|
|
//export callbackQSignalTransition_Event
|
|
func callbackQSignalTransition_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSignalTransition::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSignalTransitionFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QSignalTransition::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QSignalTransition::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QSignalTransition::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSignalTransition_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSignalTransition) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QSignalTransition::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSignalTransition_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSignalTransition_EventTest
|
|
func callbackQSignalTransition_EventTest(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSignalTransition::eventTest")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventTest"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSignalTransitionFromPointer(ptr).EventTestDefault(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectEventTest(f func(event *QEvent) bool) {
|
|
defer qt.Recovering("connect QSignalTransition::eventTest")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventTest", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectEventTest() {
|
|
defer qt.Recovering("disconnect QSignalTransition::eventTest")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventTest")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) EventTest(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSignalTransition::eventTest")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSignalTransition_EventTest(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSignalTransition) EventTestDefault(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSignalTransition::eventTest")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSignalTransition_EventTestDefault(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSignalTransition_OnTransition
|
|
func callbackQSignalTransition_OnTransition(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalTransition::onTransition")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onTransition"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQSignalTransitionFromPointer(ptr).OnTransitionDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectOnTransition(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QSignalTransition::onTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onTransition", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectOnTransition() {
|
|
defer qt.Recovering("disconnect QSignalTransition::onTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onTransition")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) OnTransition(event QEvent_ITF) {
|
|
defer qt.Recovering("QSignalTransition::onTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_OnTransition(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) OnTransitionDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QSignalTransition::onTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_OnTransitionDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) SenderObject() *QObject {
|
|
defer qt.Recovering("QSignalTransition::senderObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QSignalTransition_SenderObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSignalTransition_SenderObjectChanged
|
|
func callbackQSignalTransition_SenderObjectChanged(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSignalTransition::senderObjectChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "senderObjectChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectSenderObjectChanged(f func()) {
|
|
defer qt.Recovering("connect QSignalTransition::senderObjectChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_ConnectSenderObjectChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "senderObjectChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectSenderObjectChanged() {
|
|
defer qt.Recovering("disconnect QSignalTransition::senderObjectChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_DisconnectSenderObjectChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "senderObjectChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) SetSenderObject(sender QObject_ITF) {
|
|
defer qt.Recovering("QSignalTransition::setSenderObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_SetSenderObject(ptr.Pointer(), PointerFromQObject(sender))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) SetSignal(sign string) {
|
|
defer qt.Recovering("QSignalTransition::setSignal")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_SetSignal(ptr.Pointer(), C.CString(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) Signal() string {
|
|
defer qt.Recovering("QSignalTransition::signal")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QSignalTransition_Signal(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQSignalTransition_SignalChanged
|
|
func callbackQSignalTransition_SignalChanged(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSignalTransition::signalChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "signalChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectSignalChanged(f func()) {
|
|
defer qt.Recovering("connect QSignalTransition::signalChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_ConnectSignalChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "signalChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectSignalChanged() {
|
|
defer qt.Recovering("disconnect QSignalTransition::signalChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_DisconnectSignalChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "signalChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DestroyQSignalTransition() {
|
|
defer qt.Recovering("QSignalTransition::~QSignalTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSignalTransition_DestroyQSignalTransition(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalTransition_TimerEvent
|
|
func callbackQSignalTransition_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalTransition::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQSignalTransitionFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QSignalTransition::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QSignalTransition::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSignalTransition::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSignalTransition::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalTransition_ChildEvent
|
|
func callbackQSignalTransition_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalTransition::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQSignalTransitionFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QSignalTransition::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QSignalTransition::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSignalTransition::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSignalTransition::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalTransition_ConnectNotify
|
|
func callbackQSignalTransition_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalTransition::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSignalTransitionFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSignalTransition::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QSignalTransition::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSignalTransition::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSignalTransition::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalTransition_CustomEvent
|
|
func callbackQSignalTransition_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalTransition::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQSignalTransitionFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QSignalTransition::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QSignalTransition::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QSignalTransition::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QSignalTransition::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalTransition_DeleteLater
|
|
func callbackQSignalTransition_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSignalTransition::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSignalTransitionFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QSignalTransition::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QSignalTransition::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DeleteLater() {
|
|
defer qt.Recovering("QSignalTransition::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSignalTransition_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DeleteLaterDefault() {
|
|
defer qt.Recovering("QSignalTransition::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSignalTransition_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalTransition_DisconnectNotify
|
|
func callbackQSignalTransition_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSignalTransition::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSignalTransitionFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSignalTransition::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QSignalTransition::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSignalTransition::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSignalTransition::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSignalTransition_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSignalTransition_EventFilter
|
|
func callbackQSignalTransition_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSignalTransition::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSignalTransitionFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QSignalTransition::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QSignalTransition::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSignalTransition::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSignalTransition_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSignalTransition) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSignalTransition::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSignalTransition_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSignalTransition_MetaObject
|
|
func callbackQSignalTransition_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSignalTransition::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQSignalTransitionFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QSignalTransition) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QSignalTransition::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QSignalTransition::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSignalTransition) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QSignalTransition::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSignalTransition_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSignalTransition) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QSignalTransition::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSignalTransition_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QSize struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSize_ITF interface {
|
|
QSize_PTR() *QSize
|
|
}
|
|
|
|
func (p *QSize) QSize_PTR() *QSize {
|
|
return p
|
|
}
|
|
|
|
func (p *QSize) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSize) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQSize(ptr QSize_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSize_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSizeFromPointer(ptr unsafe.Pointer) *QSize {
|
|
var n = new(QSize)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSizeFromPointer(ptr unsafe.Pointer) *QSize {
|
|
var n = NewQSizeFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQSize() *QSize {
|
|
defer qt.Recovering("QSize::QSize")
|
|
|
|
return newQSizeFromPointer(C.QSize_NewQSize())
|
|
}
|
|
|
|
func NewQSize2(width int, height int) *QSize {
|
|
defer qt.Recovering("QSize::QSize")
|
|
|
|
return newQSizeFromPointer(C.QSize_NewQSize2(C.int(width), C.int(height)))
|
|
}
|
|
|
|
func (ptr *QSize) BoundedTo(otherSize QSize_ITF) *QSize {
|
|
defer qt.Recovering("QSize::boundedTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QSize_BoundedTo(ptr.Pointer(), PointerFromQSize(otherSize)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSize) ExpandedTo(otherSize QSize_ITF) *QSize {
|
|
defer qt.Recovering("QSize::expandedTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QSize_ExpandedTo(ptr.Pointer(), PointerFromQSize(otherSize)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSize) Height() int {
|
|
defer qt.Recovering("QSize::height")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSize_Height(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSize) IsEmpty() bool {
|
|
defer qt.Recovering("QSize::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSize_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSize) IsNull() bool {
|
|
defer qt.Recovering("QSize::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSize_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSize) IsValid() bool {
|
|
defer qt.Recovering("QSize::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSize_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSize) Rheight() int {
|
|
defer qt.Recovering("QSize::rheight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSize_Rheight(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSize) Rwidth() int {
|
|
defer qt.Recovering("QSize::rwidth")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSize_Rwidth(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSize) Scale2(size QSize_ITF, mode Qt__AspectRatioMode) {
|
|
defer qt.Recovering("QSize::scale")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSize_Scale2(ptr.Pointer(), PointerFromQSize(size), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSize) Scale(width int, height int, mode Qt__AspectRatioMode) {
|
|
defer qt.Recovering("QSize::scale")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSize_Scale(ptr.Pointer(), C.int(width), C.int(height), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSize) Scaled2(s QSize_ITF, mode Qt__AspectRatioMode) *QSize {
|
|
defer qt.Recovering("QSize::scaled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QSize_Scaled2(ptr.Pointer(), PointerFromQSize(s), C.int(mode)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSize) Scaled(width int, height int, mode Qt__AspectRatioMode) *QSize {
|
|
defer qt.Recovering("QSize::scaled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QSize_Scaled(ptr.Pointer(), C.int(width), C.int(height), C.int(mode)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSize) SetHeight(height int) {
|
|
defer qt.Recovering("QSize::setHeight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSize_SetHeight(ptr.Pointer(), C.int(height))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSize) SetWidth(width int) {
|
|
defer qt.Recovering("QSize::setWidth")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSize_SetWidth(ptr.Pointer(), C.int(width))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSize) Transpose() {
|
|
defer qt.Recovering("QSize::transpose")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSize_Transpose(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSize) Transposed() *QSize {
|
|
defer qt.Recovering("QSize::transposed")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QSize_Transposed(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSize) Width() int {
|
|
defer qt.Recovering("QSize::width")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSize_Width(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QSizeF struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSizeF_ITF interface {
|
|
QSizeF_PTR() *QSizeF
|
|
}
|
|
|
|
func (p *QSizeF) QSizeF_PTR() *QSizeF {
|
|
return p
|
|
}
|
|
|
|
func (p *QSizeF) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSizeF) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQSizeF(ptr QSizeF_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSizeF_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSizeFFromPointer(ptr unsafe.Pointer) *QSizeF {
|
|
var n = new(QSizeF)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSizeFFromPointer(ptr unsafe.Pointer) *QSizeF {
|
|
var n = NewQSizeFFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQSizeF() *QSizeF {
|
|
defer qt.Recovering("QSizeF::QSizeF")
|
|
|
|
return newQSizeFFromPointer(C.QSizeF_NewQSizeF())
|
|
}
|
|
|
|
func NewQSizeF2(size QSize_ITF) *QSizeF {
|
|
defer qt.Recovering("QSizeF::QSizeF")
|
|
|
|
return newQSizeFFromPointer(C.QSizeF_NewQSizeF2(PointerFromQSize(size)))
|
|
}
|
|
|
|
func NewQSizeF3(width float64, height float64) *QSizeF {
|
|
defer qt.Recovering("QSizeF::QSizeF")
|
|
|
|
return newQSizeFFromPointer(C.QSizeF_NewQSizeF3(C.double(width), C.double(height)))
|
|
}
|
|
|
|
func (ptr *QSizeF) BoundedTo(otherSize QSizeF_ITF) *QSizeF {
|
|
defer qt.Recovering("QSizeF::boundedTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFFromPointer(C.QSizeF_BoundedTo(ptr.Pointer(), PointerFromQSizeF(otherSize)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSizeF) ExpandedTo(otherSize QSizeF_ITF) *QSizeF {
|
|
defer qt.Recovering("QSizeF::expandedTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFFromPointer(C.QSizeF_ExpandedTo(ptr.Pointer(), PointerFromQSizeF(otherSize)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSizeF) Height() float64 {
|
|
defer qt.Recovering("QSizeF::height")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QSizeF_Height(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSizeF) IsEmpty() bool {
|
|
defer qt.Recovering("QSizeF::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSizeF_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSizeF) IsNull() bool {
|
|
defer qt.Recovering("QSizeF::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSizeF_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSizeF) IsValid() bool {
|
|
defer qt.Recovering("QSizeF::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSizeF_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSizeF) Rheight() float64 {
|
|
defer qt.Recovering("QSizeF::rheight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QSizeF_Rheight(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSizeF) Rwidth() float64 {
|
|
defer qt.Recovering("QSizeF::rwidth")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QSizeF_Rwidth(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSizeF) Scale2(size QSizeF_ITF, mode Qt__AspectRatioMode) {
|
|
defer qt.Recovering("QSizeF::scale")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSizeF_Scale2(ptr.Pointer(), PointerFromQSizeF(size), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSizeF) Scale(width float64, height float64, mode Qt__AspectRatioMode) {
|
|
defer qt.Recovering("QSizeF::scale")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSizeF_Scale(ptr.Pointer(), C.double(width), C.double(height), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSizeF) Scaled2(s QSizeF_ITF, mode Qt__AspectRatioMode) *QSizeF {
|
|
defer qt.Recovering("QSizeF::scaled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFFromPointer(C.QSizeF_Scaled2(ptr.Pointer(), PointerFromQSizeF(s), C.int(mode)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSizeF) Scaled(width float64, height float64, mode Qt__AspectRatioMode) *QSizeF {
|
|
defer qt.Recovering("QSizeF::scaled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFFromPointer(C.QSizeF_Scaled(ptr.Pointer(), C.double(width), C.double(height), C.int(mode)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSizeF) SetHeight(height float64) {
|
|
defer qt.Recovering("QSizeF::setHeight")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSizeF_SetHeight(ptr.Pointer(), C.double(height))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSizeF) SetWidth(width float64) {
|
|
defer qt.Recovering("QSizeF::setWidth")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSizeF_SetWidth(ptr.Pointer(), C.double(width))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSizeF) ToSize() *QSize {
|
|
defer qt.Recovering("QSizeF::toSize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QSizeF_ToSize(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSizeF) Transpose() {
|
|
defer qt.Recovering("QSizeF::transpose")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSizeF_Transpose(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSizeF) Transposed() *QSizeF {
|
|
defer qt.Recovering("QSizeF::transposed")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFFromPointer(C.QSizeF_Transposed(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSizeF) Width() float64 {
|
|
defer qt.Recovering("QSizeF::width")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QSizeF_Width(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//QSocketNotifier::Type
|
|
type QSocketNotifier__Type int64
|
|
|
|
const (
|
|
QSocketNotifier__Read = QSocketNotifier__Type(0)
|
|
QSocketNotifier__Write = QSocketNotifier__Type(1)
|
|
QSocketNotifier__Exception = QSocketNotifier__Type(2)
|
|
)
|
|
|
|
type QSocketNotifier struct {
|
|
QObject
|
|
}
|
|
|
|
type QSocketNotifier_ITF interface {
|
|
QObject_ITF
|
|
QSocketNotifier_PTR() *QSocketNotifier
|
|
}
|
|
|
|
func (p *QSocketNotifier) QSocketNotifier_PTR() *QSocketNotifier {
|
|
return p
|
|
}
|
|
|
|
func (p *QSocketNotifier) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSocketNotifier) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQSocketNotifier(ptr QSocketNotifier_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSocketNotifier_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSocketNotifierFromPointer(ptr unsafe.Pointer) *QSocketNotifier {
|
|
var n = new(QSocketNotifier)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSocketNotifierFromPointer(ptr unsafe.Pointer) *QSocketNotifier {
|
|
var n = NewQSocketNotifierFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QSocketNotifier_") {
|
|
n.SetObjectName("QSocketNotifier_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
//export callbackQSocketNotifier_Activated
|
|
func callbackQSocketNotifier_Activated(ptr unsafe.Pointer, ptrName *C.char, socket C.int) {
|
|
defer qt.Recovering("callback QSocketNotifier::activated")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "activated"); signal != nil {
|
|
signal.(func(int))(int(socket))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectActivated(f func(socket int)) {
|
|
defer qt.Recovering("connect QSocketNotifier::activated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_ConnectActivated(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "activated", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectActivated() {
|
|
defer qt.Recovering("disconnect QSocketNotifier::activated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_DisconnectActivated(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "activated")
|
|
}
|
|
}
|
|
|
|
//export callbackQSocketNotifier_Event
|
|
func callbackQSocketNotifier_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSocketNotifier::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSocketNotifierFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QSocketNotifier::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QSocketNotifier::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QSocketNotifier::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSocketNotifier_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QSocketNotifier::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSocketNotifier_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) IsEnabled() bool {
|
|
defer qt.Recovering("QSocketNotifier::isEnabled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSocketNotifier_IsEnabled(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSocketNotifier_SetEnabled
|
|
func callbackQSocketNotifier_SetEnabled(ptr unsafe.Pointer, ptrName *C.char, enable C.int) {
|
|
defer qt.Recovering("callback QSocketNotifier::setEnabled")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setEnabled"); signal != nil {
|
|
signal.(func(bool))(int(enable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectSetEnabled(f func(enable bool)) {
|
|
defer qt.Recovering("connect QSocketNotifier::setEnabled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setEnabled", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectSetEnabled(enable bool) {
|
|
defer qt.Recovering("disconnect QSocketNotifier::setEnabled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setEnabled")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) SetEnabled(enable bool) {
|
|
defer qt.Recovering("QSocketNotifier::setEnabled")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_SetEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) Type() QSocketNotifier__Type {
|
|
defer qt.Recovering("QSocketNotifier::type")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QSocketNotifier__Type(C.QSocketNotifier_Type(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DestroyQSocketNotifier() {
|
|
defer qt.Recovering("QSocketNotifier::~QSocketNotifier")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSocketNotifier_DestroyQSocketNotifier(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSocketNotifier_TimerEvent
|
|
func callbackQSocketNotifier_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSocketNotifier::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQSocketNotifierFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QSocketNotifier::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QSocketNotifier::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSocketNotifier::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSocketNotifier::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSocketNotifier_ChildEvent
|
|
func callbackQSocketNotifier_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSocketNotifier::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQSocketNotifierFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QSocketNotifier::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QSocketNotifier::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSocketNotifier::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSocketNotifier::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSocketNotifier_ConnectNotify
|
|
func callbackQSocketNotifier_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSocketNotifier::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSocketNotifierFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSocketNotifier::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QSocketNotifier::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSocketNotifier::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSocketNotifier::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSocketNotifier_CustomEvent
|
|
func callbackQSocketNotifier_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSocketNotifier::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQSocketNotifierFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QSocketNotifier::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QSocketNotifier::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QSocketNotifier::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QSocketNotifier::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSocketNotifier_DeleteLater
|
|
func callbackQSocketNotifier_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSocketNotifier::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSocketNotifierFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QSocketNotifier::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QSocketNotifier::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DeleteLater() {
|
|
defer qt.Recovering("QSocketNotifier::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSocketNotifier_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DeleteLaterDefault() {
|
|
defer qt.Recovering("QSocketNotifier::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSocketNotifier_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSocketNotifier_DisconnectNotify
|
|
func callbackQSocketNotifier_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSocketNotifier::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSocketNotifierFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSocketNotifier::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QSocketNotifier::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSocketNotifier::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSocketNotifier::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSocketNotifier_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSocketNotifier_EventFilter
|
|
func callbackQSocketNotifier_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSocketNotifier::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSocketNotifierFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QSocketNotifier::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QSocketNotifier::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSocketNotifier::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSocketNotifier_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSocketNotifier::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSocketNotifier_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSocketNotifier_MetaObject
|
|
func callbackQSocketNotifier_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSocketNotifier::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQSocketNotifierFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QSocketNotifier::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QSocketNotifier::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QSocketNotifier::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSocketNotifier_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSocketNotifier) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QSocketNotifier::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSocketNotifier_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QSortFilterProxyModel struct {
|
|
QAbstractProxyModel
|
|
}
|
|
|
|
type QSortFilterProxyModel_ITF interface {
|
|
QAbstractProxyModel_ITF
|
|
QSortFilterProxyModel_PTR() *QSortFilterProxyModel
|
|
}
|
|
|
|
func (p *QSortFilterProxyModel) QSortFilterProxyModel_PTR() *QSortFilterProxyModel {
|
|
return p
|
|
}
|
|
|
|
func (p *QSortFilterProxyModel) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractProxyModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSortFilterProxyModel) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractProxyModel_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQSortFilterProxyModel(ptr QSortFilterProxyModel_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSortFilterProxyModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSortFilterProxyModelFromPointer(ptr unsafe.Pointer) *QSortFilterProxyModel {
|
|
var n = new(QSortFilterProxyModel)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSortFilterProxyModelFromPointer(ptr unsafe.Pointer) *QSortFilterProxyModel {
|
|
var n = NewQSortFilterProxyModelFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QSortFilterProxyModel_") {
|
|
n.SetObjectName("QSortFilterProxyModel_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DynamicSortFilter() bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::dynamicSortFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_DynamicSortFilter(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) FilterCaseSensitivity() Qt__CaseSensitivity {
|
|
defer qt.Recovering("QSortFilterProxyModel::filterCaseSensitivity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__CaseSensitivity(C.QSortFilterProxyModel_FilterCaseSensitivity(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) FilterKeyColumn() int {
|
|
defer qt.Recovering("QSortFilterProxyModel::filterKeyColumn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSortFilterProxyModel_FilterKeyColumn(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) FilterRegExp() *QRegExp {
|
|
defer qt.Recovering("QSortFilterProxyModel::filterRegExp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRegExpFromPointer(C.QSortFilterProxyModel_FilterRegExp(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) FilterRole() int {
|
|
defer qt.Recovering("QSortFilterProxyModel::filterRole")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSortFilterProxyModel_FilterRole(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) IsSortLocaleAware() bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::isSortLocaleAware")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_IsSortLocaleAware(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetDynamicSortFilter(enable bool) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setDynamicSortFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetDynamicSortFilter(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetFilterCaseSensitivity(cs Qt__CaseSensitivity) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setFilterCaseSensitivity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetFilterCaseSensitivity(ptr.Pointer(), C.int(cs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetFilterKeyColumn(column int) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setFilterKeyColumn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetFilterKeyColumn(ptr.Pointer(), C.int(column))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetFilterRegExp(regExp QRegExp_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setFilterRegExp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetFilterRegExp(ptr.Pointer(), PointerFromQRegExp(regExp))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetFilterRole(role int) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setFilterRole")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetFilterRole(ptr.Pointer(), C.int(role))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetSortCaseSensitivity(cs Qt__CaseSensitivity) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setSortCaseSensitivity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetSortCaseSensitivity(ptr.Pointer(), C.int(cs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetSortLocaleAware(on bool) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setSortLocaleAware")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetSortLocaleAware(ptr.Pointer(), C.int(qt.GoBoolToInt(on)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetSortRole(role int) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setSortRole")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetSortRole(ptr.Pointer(), C.int(role))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SortCaseSensitivity() Qt__CaseSensitivity {
|
|
defer qt.Recovering("QSortFilterProxyModel::sortCaseSensitivity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__CaseSensitivity(C.QSortFilterProxyModel_SortCaseSensitivity(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SortRole() int {
|
|
defer qt.Recovering("QSortFilterProxyModel::sortRole")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSortFilterProxyModel_SortRole(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func NewQSortFilterProxyModel(parent QObject_ITF) *QSortFilterProxyModel {
|
|
defer qt.Recovering("QSortFilterProxyModel::QSortFilterProxyModel")
|
|
|
|
return newQSortFilterProxyModelFromPointer(C.QSortFilterProxyModel_NewQSortFilterProxyModel(PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_Buddy
|
|
func callbackQSortFilterProxyModel_Buddy(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::buddy")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "buddy"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQSortFilterProxyModelFromPointer(ptr).BuddyDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectBuddy(f func(index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "buddy", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectBuddy() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "buddy")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) Buddy(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QSortFilterProxyModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QSortFilterProxyModel_Buddy(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) BuddyDefault(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QSortFilterProxyModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QSortFilterProxyModel_BuddyDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_CanFetchMore
|
|
func callbackQSortFilterProxyModel_CanFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::canFetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canFetchMore"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).CanFetchMoreDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectCanFetchMore(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canFetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectCanFetchMore() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canFetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) CanFetchMore(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_CanFetchMore(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) CanFetchMoreDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_CanFetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_ColumnCount
|
|
func callbackQSortFilterProxyModel_ColumnCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::columnCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(NewQSortFilterProxyModelFromPointer(ptr).ColumnCountDefault(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectColumnCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectColumnCount() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ColumnCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QSortFilterProxyModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSortFilterProxyModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ColumnCountDefault(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QSortFilterProxyModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSortFilterProxyModel_ColumnCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_Data
|
|
func callbackQSortFilterProxyModel_Data(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::data")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "data"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(*QModelIndex, int) *QVariant)(NewQModelIndexFromPointer(index), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQSortFilterProxyModelFromPointer(ptr).DataDefault(NewQModelIndexFromPointer(index), int(role)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectData(f func(index *QModelIndex, role int) *QVariant) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "data", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectData() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "data")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) Data(index QModelIndex_ITF, role int) *QVariant {
|
|
defer qt.Recovering("QSortFilterProxyModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QSortFilterProxyModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DataDefault(index QModelIndex_ITF, role int) *QVariant {
|
|
defer qt.Recovering("QSortFilterProxyModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QSortFilterProxyModel_DataDefault(ptr.Pointer(), PointerFromQModelIndex(index), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_DropMimeData
|
|
func callbackQSortFilterProxyModel_DropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::dropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "dropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).DropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "dropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectDropMimeData() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "dropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_DropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_FetchMore
|
|
func callbackQSortFilterProxyModel_FetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::fetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
|
|
signal.(func(*QModelIndex))(NewQModelIndexFromPointer(parent))
|
|
} else {
|
|
NewQSortFilterProxyModelFromPointer(ptr).FetchMoreDefault(NewQModelIndexFromPointer(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectFetchMore(f func(parent *QModelIndex)) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectFetchMore() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) FetchMore(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_FetchMore(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) FetchMoreDefault(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_FetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_FilterAcceptsColumn
|
|
func callbackQSortFilterProxyModel_FilterAcceptsColumn(ptr unsafe.Pointer, ptrName *C.char, source_column C.int, source_parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::filterAcceptsColumn")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "filterAcceptsColumn"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, *QModelIndex) bool)(int(source_column), NewQModelIndexFromPointer(source_parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).FilterAcceptsColumnDefault(int(source_column), NewQModelIndexFromPointer(source_parent))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectFilterAcceptsColumn(f func(source_column int, source_parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::filterAcceptsColumn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "filterAcceptsColumn", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectFilterAcceptsColumn() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::filterAcceptsColumn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "filterAcceptsColumn")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) FilterAcceptsColumn(source_column int, source_parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::filterAcceptsColumn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_FilterAcceptsColumn(ptr.Pointer(), C.int(source_column), PointerFromQModelIndex(source_parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) FilterAcceptsColumnDefault(source_column int, source_parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::filterAcceptsColumn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_FilterAcceptsColumnDefault(ptr.Pointer(), C.int(source_column), PointerFromQModelIndex(source_parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_FilterAcceptsRow
|
|
func callbackQSortFilterProxyModel_FilterAcceptsRow(ptr unsafe.Pointer, ptrName *C.char, source_row C.int, source_parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::filterAcceptsRow")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "filterAcceptsRow"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, *QModelIndex) bool)(int(source_row), NewQModelIndexFromPointer(source_parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).FilterAcceptsRowDefault(int(source_row), NewQModelIndexFromPointer(source_parent))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectFilterAcceptsRow(f func(source_row int, source_parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::filterAcceptsRow")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "filterAcceptsRow", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectFilterAcceptsRow() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::filterAcceptsRow")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "filterAcceptsRow")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) FilterAcceptsRow(source_row int, source_parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::filterAcceptsRow")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_FilterAcceptsRow(ptr.Pointer(), C.int(source_row), PointerFromQModelIndex(source_parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) FilterAcceptsRowDefault(source_row int, source_parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::filterAcceptsRow")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_FilterAcceptsRowDefault(ptr.Pointer(), C.int(source_row), PointerFromQModelIndex(source_parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_Flags
|
|
func callbackQSortFilterProxyModel_Flags(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::flags")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "flags"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) Qt__ItemFlag)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return C.int(NewQSortFilterProxyModelFromPointer(ptr).FlagsDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectFlags(f func(index *QModelIndex) Qt__ItemFlag) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "flags", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectFlags() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "flags")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QSortFilterProxyModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QSortFilterProxyModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) FlagsDefault(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QSortFilterProxyModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QSortFilterProxyModel_FlagsDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_HasChildren
|
|
func callbackQSortFilterProxyModel_HasChildren(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::hasChildren")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "hasChildren"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).HasChildrenDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectHasChildren(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "hasChildren", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectHasChildren() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "hasChildren")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) HasChildren(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_HasChildren(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) HasChildrenDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_HasChildrenDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_HeaderData
|
|
func callbackQSortFilterProxyModel_HeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::headerData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "headerData"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(int, Qt__Orientation, int) *QVariant)(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQSortFilterProxyModelFromPointer(ptr).HeaderDataDefault(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectHeaderData(f func(section int, orientation Qt__Orientation, role int) *QVariant) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "headerData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectHeaderData() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "headerData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) HeaderData(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QSortFilterProxyModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QSortFilterProxyModel_HeaderData(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) HeaderDataDefault(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QSortFilterProxyModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QSortFilterProxyModel_HeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_Index
|
|
func callbackQSortFilterProxyModel_Index(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::index")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "index"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQSortFilterProxyModelFromPointer(ptr).IndexDefault(int(row), int(column), NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "index", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectIndex() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "index")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QSortFilterProxyModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QSortFilterProxyModel_Index(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) IndexDefault(row int, column int, parent QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QSortFilterProxyModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QSortFilterProxyModel_IndexDefault(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_InsertColumns
|
|
func callbackQSortFilterProxyModel_InsertColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::insertColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).InsertColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectInsertColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectInsertColumns() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) InsertColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_InsertColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) InsertColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_InsertColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_InsertRows
|
|
func callbackQSortFilterProxyModel_InsertRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::insertRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).InsertRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectInsertRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectInsertRows() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) InsertRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_InsertRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) InsertRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_InsertRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_Invalidate
|
|
func callbackQSortFilterProxyModel_Invalidate(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::invalidate")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "invalidate"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectInvalidate(f func()) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::invalidate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "invalidate", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectInvalidate() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::invalidate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "invalidate")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) Invalidate() {
|
|
defer qt.Recovering("QSortFilterProxyModel::invalidate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_Invalidate(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) InvalidateFilter() {
|
|
defer qt.Recovering("QSortFilterProxyModel::invalidateFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_InvalidateFilter(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_LessThan
|
|
func callbackQSortFilterProxyModel_LessThan(ptr unsafe.Pointer, ptrName *C.char, source_left unsafe.Pointer, source_right unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::lessThan")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "lessThan"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, *QModelIndex) bool)(NewQModelIndexFromPointer(source_left), NewQModelIndexFromPointer(source_right))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).LessThanDefault(NewQModelIndexFromPointer(source_left), NewQModelIndexFromPointer(source_right))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectLessThan(f func(source_left *QModelIndex, source_right *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::lessThan")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "lessThan", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectLessThan() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::lessThan")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "lessThan")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) LessThan(source_left QModelIndex_ITF, source_right QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::lessThan")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_LessThan(ptr.Pointer(), PointerFromQModelIndex(source_left), PointerFromQModelIndex(source_right)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) LessThanDefault(source_left QModelIndex_ITF, source_right QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::lessThan")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_LessThanDefault(ptr.Pointer(), PointerFromQModelIndex(source_left), PointerFromQModelIndex(source_right)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_MapFromSource
|
|
func callbackQSortFilterProxyModel_MapFromSource(ptr unsafe.Pointer, ptrName *C.char, sourceIndex unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::mapFromSource")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapFromSource"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(sourceIndex)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQSortFilterProxyModelFromPointer(ptr).MapFromSourceDefault(NewQModelIndexFromPointer(sourceIndex)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectMapFromSource(f func(sourceIndex *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::mapFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapFromSource", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectMapFromSource() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::mapFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapFromSource")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MapFromSource(sourceIndex QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QSortFilterProxyModel::mapFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QSortFilterProxyModel_MapFromSource(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MapFromSourceDefault(sourceIndex QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QSortFilterProxyModel::mapFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QSortFilterProxyModel_MapFromSourceDefault(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_MapSelectionFromSource
|
|
func callbackQSortFilterProxyModel_MapSelectionFromSource(ptr unsafe.Pointer, ptrName *C.char, sourceSelection unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::mapSelectionFromSource")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapSelectionFromSource"); signal != nil {
|
|
return PointerFromQItemSelection(signal.(func(*QItemSelection) *QItemSelection)(NewQItemSelectionFromPointer(sourceSelection)))
|
|
}
|
|
|
|
return PointerFromQItemSelection(NewQSortFilterProxyModelFromPointer(ptr).MapSelectionFromSourceDefault(NewQItemSelectionFromPointer(sourceSelection)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectMapSelectionFromSource(f func(sourceSelection *QItemSelection) *QItemSelection) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::mapSelectionFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapSelectionFromSource", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectMapSelectionFromSource() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::mapSelectionFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapSelectionFromSource")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MapSelectionFromSource(sourceSelection QItemSelection_ITF) *QItemSelection {
|
|
defer qt.Recovering("QSortFilterProxyModel::mapSelectionFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QSortFilterProxyModel_MapSelectionFromSource(ptr.Pointer(), PointerFromQItemSelection(sourceSelection)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MapSelectionFromSourceDefault(sourceSelection QItemSelection_ITF) *QItemSelection {
|
|
defer qt.Recovering("QSortFilterProxyModel::mapSelectionFromSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QSortFilterProxyModel_MapSelectionFromSourceDefault(ptr.Pointer(), PointerFromQItemSelection(sourceSelection)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_MapSelectionToSource
|
|
func callbackQSortFilterProxyModel_MapSelectionToSource(ptr unsafe.Pointer, ptrName *C.char, proxySelection unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::mapSelectionToSource")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapSelectionToSource"); signal != nil {
|
|
return PointerFromQItemSelection(signal.(func(*QItemSelection) *QItemSelection)(NewQItemSelectionFromPointer(proxySelection)))
|
|
}
|
|
|
|
return PointerFromQItemSelection(NewQSortFilterProxyModelFromPointer(ptr).MapSelectionToSourceDefault(NewQItemSelectionFromPointer(proxySelection)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectMapSelectionToSource(f func(proxySelection *QItemSelection) *QItemSelection) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::mapSelectionToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapSelectionToSource", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectMapSelectionToSource() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::mapSelectionToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapSelectionToSource")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MapSelectionToSource(proxySelection QItemSelection_ITF) *QItemSelection {
|
|
defer qt.Recovering("QSortFilterProxyModel::mapSelectionToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QSortFilterProxyModel_MapSelectionToSource(ptr.Pointer(), PointerFromQItemSelection(proxySelection)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MapSelectionToSourceDefault(proxySelection QItemSelection_ITF) *QItemSelection {
|
|
defer qt.Recovering("QSortFilterProxyModel::mapSelectionToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQItemSelectionFromPointer(C.QSortFilterProxyModel_MapSelectionToSourceDefault(ptr.Pointer(), PointerFromQItemSelection(proxySelection)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_MapToSource
|
|
func callbackQSortFilterProxyModel_MapToSource(ptr unsafe.Pointer, ptrName *C.char, proxyIndex unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::mapToSource")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mapToSource"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(proxyIndex)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQSortFilterProxyModelFromPointer(ptr).MapToSourceDefault(NewQModelIndexFromPointer(proxyIndex)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectMapToSource(f func(proxyIndex *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::mapToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mapToSource", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectMapToSource() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::mapToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mapToSource")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MapToSource(proxyIndex QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QSortFilterProxyModel::mapToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QSortFilterProxyModel_MapToSource(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MapToSourceDefault(proxyIndex QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QSortFilterProxyModel::mapToSource")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QSortFilterProxyModel_MapToSourceDefault(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_MimeTypes
|
|
func callbackQSortFilterProxyModel_MimeTypes(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::mimeTypes")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mimeTypes"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(NewQSortFilterProxyModelFromPointer(ptr).MimeTypesDefault(), "|"))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectMimeTypes(f func() []string) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mimeTypes", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectMimeTypes() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mimeTypes")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MimeTypes() []string {
|
|
defer qt.Recovering("QSortFilterProxyModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QSortFilterProxyModel_MimeTypes(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MimeTypesDefault() []string {
|
|
defer qt.Recovering("QSortFilterProxyModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QSortFilterProxyModel_MimeTypesDefault(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_Parent
|
|
func callbackQSortFilterProxyModel_Parent(ptr unsafe.Pointer, ptrName *C.char, child unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::parent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "parent"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(child)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQSortFilterProxyModelFromPointer(ptr).ParentDefault(NewQModelIndexFromPointer(child)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectParent(f func(child *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "parent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectParent() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "parent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) Parent(child QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QSortFilterProxyModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QSortFilterProxyModel_Parent(ptr.Pointer(), PointerFromQModelIndex(child)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ParentDefault(child QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QSortFilterProxyModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QSortFilterProxyModel_ParentDefault(ptr.Pointer(), PointerFromQModelIndex(child)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_RemoveColumns
|
|
func callbackQSortFilterProxyModel_RemoveColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::removeColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).RemoveColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectRemoveColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectRemoveColumns() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) RemoveColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_RemoveColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) RemoveColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_RemoveColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_RemoveRows
|
|
func callbackQSortFilterProxyModel_RemoveRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::removeRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).RemoveRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectRemoveRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectRemoveRows() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) RemoveRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_RemoveRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) RemoveRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_RemoveRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_RowCount
|
|
func callbackQSortFilterProxyModel_RowCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::rowCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(NewQSortFilterProxyModelFromPointer(ptr).RowCountDefault(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectRowCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectRowCount() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) RowCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QSortFilterProxyModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSortFilterProxyModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) RowCountDefault(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QSortFilterProxyModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSortFilterProxyModel_RowCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_SetData
|
|
func callbackQSortFilterProxyModel_SetData(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::setData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, *QVariant, int) bool)(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).SetDataDefault(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectSetData(f func(index *QModelIndex, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectSetData() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetData(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_SetData(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetDataDefault(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_SetDataDefault(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_SetFilterFixedString
|
|
func callbackQSortFilterProxyModel_SetFilterFixedString(ptr unsafe.Pointer, ptrName *C.char, pattern *C.char) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::setFilterFixedString")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setFilterFixedString"); signal != nil {
|
|
signal.(func(string))(C.GoString(pattern))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectSetFilterFixedString(f func(pattern string)) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::setFilterFixedString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setFilterFixedString", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectSetFilterFixedString(pattern string) {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::setFilterFixedString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setFilterFixedString")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetFilterFixedString(pattern string) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setFilterFixedString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetFilterFixedString(ptr.Pointer(), C.CString(pattern))
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_SetFilterRegExp2
|
|
func callbackQSortFilterProxyModel_SetFilterRegExp2(ptr unsafe.Pointer, ptrName *C.char, pattern *C.char) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::setFilterRegExp")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setFilterRegExp2"); signal != nil {
|
|
signal.(func(string))(C.GoString(pattern))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectSetFilterRegExp2(f func(pattern string)) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::setFilterRegExp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setFilterRegExp2", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectSetFilterRegExp2(pattern string) {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::setFilterRegExp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setFilterRegExp2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetFilterRegExp2(pattern string) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setFilterRegExp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetFilterRegExp2(ptr.Pointer(), C.CString(pattern))
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_SetFilterWildcard
|
|
func callbackQSortFilterProxyModel_SetFilterWildcard(ptr unsafe.Pointer, ptrName *C.char, pattern *C.char) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::setFilterWildcard")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setFilterWildcard"); signal != nil {
|
|
signal.(func(string))(C.GoString(pattern))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectSetFilterWildcard(f func(pattern string)) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::setFilterWildcard")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setFilterWildcard", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectSetFilterWildcard(pattern string) {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::setFilterWildcard")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setFilterWildcard")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetFilterWildcard(pattern string) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setFilterWildcard")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetFilterWildcard(ptr.Pointer(), C.CString(pattern))
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_SetHeaderData
|
|
func callbackQSortFilterProxyModel_SetHeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::setHeaderData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setHeaderData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, Qt__Orientation, *QVariant, int) bool)(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).SetHeaderDataDefault(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectSetHeaderData(f func(section int, orientation Qt__Orientation, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setHeaderData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectSetHeaderData() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setHeaderData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetHeaderData(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_SetHeaderData(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetHeaderDataDefault(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_SetHeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_SetSourceModel
|
|
func callbackQSortFilterProxyModel_SetSourceModel(ptr unsafe.Pointer, ptrName *C.char, sourceModel unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::setSourceModel")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setSourceModel"); signal != nil {
|
|
signal.(func(*QAbstractItemModel))(NewQAbstractItemModelFromPointer(sourceModel))
|
|
} else {
|
|
NewQSortFilterProxyModelFromPointer(ptr).SetSourceModelDefault(NewQAbstractItemModelFromPointer(sourceModel))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectSetSourceModel(f func(sourceModel *QAbstractItemModel)) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::setSourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setSourceModel", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectSetSourceModel() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::setSourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setSourceModel")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetSourceModel(sourceModel QAbstractItemModel_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setSourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetSourceModel(ptr.Pointer(), PointerFromQAbstractItemModel(sourceModel))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SetSourceModelDefault(sourceModel QAbstractItemModel_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::setSourceModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SetSourceModelDefault(ptr.Pointer(), PointerFromQAbstractItemModel(sourceModel))
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_Sibling
|
|
func callbackQSortFilterProxyModel_Sibling(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, idx unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::sibling")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sibling"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(idx)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQSortFilterProxyModelFromPointer(ptr).SiblingDefault(int(row), int(column), NewQModelIndexFromPointer(idx)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectSibling(f func(row int, column int, idx *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sibling", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectSibling() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sibling")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) Sibling(row int, column int, idx QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QSortFilterProxyModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QSortFilterProxyModel_Sibling(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SiblingDefault(row int, column int, idx QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QSortFilterProxyModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QSortFilterProxyModel_SiblingDefault(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_Sort
|
|
func callbackQSortFilterProxyModel_Sort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::sort")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
|
|
signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
|
|
} else {
|
|
NewQSortFilterProxyModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sort", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectSort() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sort")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) Sort(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QSortFilterProxyModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SortDefault(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QSortFilterProxyModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SortColumn() int {
|
|
defer qt.Recovering("QSortFilterProxyModel::sortColumn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QSortFilterProxyModel_SortColumn(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SortOrder() Qt__SortOrder {
|
|
defer qt.Recovering("QSortFilterProxyModel::sortOrder")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__SortOrder(C.QSortFilterProxyModel_SortOrder(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_Span
|
|
func callbackQSortFilterProxyModel_Span(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::span")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "span"); signal != nil {
|
|
return PointerFromQSize(signal.(func(*QModelIndex) *QSize)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQSize(NewQSortFilterProxyModelFromPointer(ptr).SpanDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectSpan(f func(index *QModelIndex) *QSize) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "span", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectSpan() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "span")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) Span(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QSortFilterProxyModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QSortFilterProxyModel_Span(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SpanDefault(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QSortFilterProxyModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QSortFilterProxyModel_SpanDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_SupportedDropActions
|
|
func callbackQSortFilterProxyModel_SupportedDropActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::supportedDropActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDropActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQSortFilterProxyModelFromPointer(ptr).SupportedDropActionsDefault())
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectSupportedDropActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDropActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectSupportedDropActions() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDropActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SupportedDropActions() Qt__DropAction {
|
|
defer qt.Recovering("QSortFilterProxyModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QSortFilterProxyModel_SupportedDropActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SupportedDropActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QSortFilterProxyModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QSortFilterProxyModel_SupportedDropActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DestroyQSortFilterProxyModel() {
|
|
defer qt.Recovering("QSortFilterProxyModel::~QSortFilterProxyModel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSortFilterProxyModel_DestroyQSortFilterProxyModel(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_CanDropMimeData
|
|
func callbackQSortFilterProxyModel_CanDropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::canDropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canDropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).CanDropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectCanDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canDropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectCanDropMimeData() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canDropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) CanDropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_CanDropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) CanDropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_CanDropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_ResetInternalData
|
|
func callbackQSortFilterProxyModel_ResetInternalData(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::resetInternalData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resetInternalData"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSortFilterProxyModelFromPointer(ptr).ResetInternalDataDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectResetInternalData(f func()) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resetInternalData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectResetInternalData() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resetInternalData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ResetInternalData() {
|
|
defer qt.Recovering("QSortFilterProxyModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_ResetInternalData(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ResetInternalDataDefault() {
|
|
defer qt.Recovering("QSortFilterProxyModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_ResetInternalDataDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_Revert
|
|
func callbackQSortFilterProxyModel_Revert(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::revert")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSortFilterProxyModelFromPointer(ptr).RevertDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectRevert(f func()) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "revert", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectRevert() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "revert")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) Revert() {
|
|
defer qt.Recovering("QSortFilterProxyModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_Revert(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) RevertDefault() {
|
|
defer qt.Recovering("QSortFilterProxyModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_RevertDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_Submit
|
|
func callbackQSortFilterProxyModel_Submit(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::submit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "submit"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).SubmitDefault()))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectSubmit(f func() bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "submit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectSubmit() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "submit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) Submit() bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_Submit(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SubmitDefault() bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_SubmitDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_SupportedDragActions
|
|
func callbackQSortFilterProxyModel_SupportedDragActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::supportedDragActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDragActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQSortFilterProxyModelFromPointer(ptr).SupportedDragActionsDefault())
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectSupportedDragActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDragActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectSupportedDragActions() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDragActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SupportedDragActions() Qt__DropAction {
|
|
defer qt.Recovering("QSortFilterProxyModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QSortFilterProxyModel_SupportedDragActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) SupportedDragActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QSortFilterProxyModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QSortFilterProxyModel_SupportedDragActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_MoveColumns
|
|
func callbackQSortFilterProxyModel_MoveColumns(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceColumn C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::moveColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).MoveColumnsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectMoveColumns(f func(sourceParent *QModelIndex, sourceColumn int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectMoveColumns() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MoveColumns(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_MoveColumns(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MoveColumnsDefault(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_MoveColumnsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_MoveRows
|
|
func callbackQSortFilterProxyModel_MoveRows(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceRow C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::moveRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).MoveRowsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectMoveRows(f func(sourceParent *QModelIndex, sourceRow int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectMoveRows() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MoveRows(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_MoveRows(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MoveRowsDefault(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_MoveRowsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_TimerEvent
|
|
func callbackQSortFilterProxyModel_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQSortFilterProxyModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_ChildEvent
|
|
func callbackQSortFilterProxyModel_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQSortFilterProxyModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_ConnectNotify
|
|
func callbackQSortFilterProxyModel_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSortFilterProxyModelFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_CustomEvent
|
|
func callbackQSortFilterProxyModel_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQSortFilterProxyModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_DeleteLater
|
|
func callbackQSortFilterProxyModel_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSortFilterProxyModelFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DeleteLater() {
|
|
defer qt.Recovering("QSortFilterProxyModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSortFilterProxyModel_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DeleteLaterDefault() {
|
|
defer qt.Recovering("QSortFilterProxyModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QSortFilterProxyModel_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_DisconnectNotify
|
|
func callbackQSortFilterProxyModel_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSortFilterProxyModelFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QSortFilterProxyModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSortFilterProxyModel_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_Event
|
|
func callbackQSortFilterProxyModel_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_EventFilter
|
|
func callbackQSortFilterProxyModel_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QSortFilterProxyModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSortFilterProxyModel_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSortFilterProxyModel_MetaObject
|
|
func callbackQSortFilterProxyModel_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QSortFilterProxyModel::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQSortFilterProxyModelFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QSortFilterProxyModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QSortFilterProxyModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QSortFilterProxyModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSortFilterProxyModel_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSortFilterProxyModel) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QSortFilterProxyModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QSortFilterProxyModel_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QStack struct {
|
|
QVector
|
|
}
|
|
|
|
type QStack_ITF interface {
|
|
QVector_ITF
|
|
QStack_PTR() *QStack
|
|
}
|
|
|
|
func (p *QStack) QStack_PTR() *QStack {
|
|
return p
|
|
}
|
|
|
|
func (p *QStack) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QVector_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QStack) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QVector_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQStack(ptr QStack_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QStack_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQStackFromPointer(ptr unsafe.Pointer) *QStack {
|
|
var n = new(QStack)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQStackFromPointer(ptr unsafe.Pointer) *QStack {
|
|
var n = NewQStackFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QStandardPaths::LocateOption
|
|
type QStandardPaths__LocateOption int64
|
|
|
|
const (
|
|
QStandardPaths__LocateFile = QStandardPaths__LocateOption(0x0)
|
|
QStandardPaths__LocateDirectory = QStandardPaths__LocateOption(0x1)
|
|
)
|
|
|
|
//QStandardPaths::StandardLocation
|
|
type QStandardPaths__StandardLocation int64
|
|
|
|
const (
|
|
QStandardPaths__DesktopLocation = QStandardPaths__StandardLocation(0)
|
|
QStandardPaths__DocumentsLocation = QStandardPaths__StandardLocation(1)
|
|
QStandardPaths__FontsLocation = QStandardPaths__StandardLocation(2)
|
|
QStandardPaths__ApplicationsLocation = QStandardPaths__StandardLocation(3)
|
|
QStandardPaths__MusicLocation = QStandardPaths__StandardLocation(4)
|
|
QStandardPaths__MoviesLocation = QStandardPaths__StandardLocation(5)
|
|
QStandardPaths__PicturesLocation = QStandardPaths__StandardLocation(6)
|
|
QStandardPaths__TempLocation = QStandardPaths__StandardLocation(7)
|
|
QStandardPaths__HomeLocation = QStandardPaths__StandardLocation(8)
|
|
QStandardPaths__DataLocation = QStandardPaths__StandardLocation(9)
|
|
QStandardPaths__CacheLocation = QStandardPaths__StandardLocation(10)
|
|
QStandardPaths__GenericDataLocation = QStandardPaths__StandardLocation(11)
|
|
QStandardPaths__RuntimeLocation = QStandardPaths__StandardLocation(12)
|
|
QStandardPaths__ConfigLocation = QStandardPaths__StandardLocation(13)
|
|
QStandardPaths__DownloadLocation = QStandardPaths__StandardLocation(14)
|
|
QStandardPaths__GenericCacheLocation = QStandardPaths__StandardLocation(15)
|
|
QStandardPaths__GenericConfigLocation = QStandardPaths__StandardLocation(16)
|
|
QStandardPaths__AppDataLocation = QStandardPaths__StandardLocation(17)
|
|
QStandardPaths__AppConfigLocation = QStandardPaths__StandardLocation(18)
|
|
QStandardPaths__AppLocalDataLocation = QStandardPaths__StandardLocation(QStandardPaths__DataLocation)
|
|
)
|
|
|
|
type QStandardPaths struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QStandardPaths_ITF interface {
|
|
QStandardPaths_PTR() *QStandardPaths
|
|
}
|
|
|
|
func (p *QStandardPaths) QStandardPaths_PTR() *QStandardPaths {
|
|
return p
|
|
}
|
|
|
|
func (p *QStandardPaths) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QStandardPaths) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQStandardPaths(ptr QStandardPaths_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QStandardPaths_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQStandardPathsFromPointer(ptr unsafe.Pointer) *QStandardPaths {
|
|
var n = new(QStandardPaths)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQStandardPathsFromPointer(ptr unsafe.Pointer) *QStandardPaths {
|
|
var n = NewQStandardPathsFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func QStandardPaths_SetTestModeEnabled(testMode bool) {
|
|
defer qt.Recovering("QStandardPaths::setTestModeEnabled")
|
|
|
|
C.QStandardPaths_QStandardPaths_SetTestModeEnabled(C.int(qt.GoBoolToInt(testMode)))
|
|
}
|
|
|
|
func (ptr *QStandardPaths) SetTestModeEnabled(testMode bool) {
|
|
defer qt.Recovering("QStandardPaths::setTestModeEnabled")
|
|
|
|
C.QStandardPaths_QStandardPaths_SetTestModeEnabled(C.int(qt.GoBoolToInt(testMode)))
|
|
}
|
|
|
|
func QStandardPaths_FindExecutable(executableName string, paths []string) string {
|
|
defer qt.Recovering("QStandardPaths::findExecutable")
|
|
|
|
return C.GoString(C.QStandardPaths_QStandardPaths_FindExecutable(C.CString(executableName), C.CString(strings.Join(paths, "|"))))
|
|
}
|
|
|
|
func (ptr *QStandardPaths) FindExecutable(executableName string, paths []string) string {
|
|
defer qt.Recovering("QStandardPaths::findExecutable")
|
|
|
|
return C.GoString(C.QStandardPaths_QStandardPaths_FindExecutable(C.CString(executableName), C.CString(strings.Join(paths, "|"))))
|
|
}
|
|
|
|
func QStandardPaths_Locate(ty QStandardPaths__StandardLocation, fileName string, options QStandardPaths__LocateOption) string {
|
|
defer qt.Recovering("QStandardPaths::locate")
|
|
|
|
return C.GoString(C.QStandardPaths_QStandardPaths_Locate(C.int(ty), C.CString(fileName), C.int(options)))
|
|
}
|
|
|
|
func (ptr *QStandardPaths) Locate(ty QStandardPaths__StandardLocation, fileName string, options QStandardPaths__LocateOption) string {
|
|
defer qt.Recovering("QStandardPaths::locate")
|
|
|
|
return C.GoString(C.QStandardPaths_QStandardPaths_Locate(C.int(ty), C.CString(fileName), C.int(options)))
|
|
}
|
|
|
|
func QStandardPaths_LocateAll(ty QStandardPaths__StandardLocation, fileName string, options QStandardPaths__LocateOption) []string {
|
|
defer qt.Recovering("QStandardPaths::locateAll")
|
|
|
|
return strings.Split(C.GoString(C.QStandardPaths_QStandardPaths_LocateAll(C.int(ty), C.CString(fileName), C.int(options))), "|")
|
|
}
|
|
|
|
func (ptr *QStandardPaths) LocateAll(ty QStandardPaths__StandardLocation, fileName string, options QStandardPaths__LocateOption) []string {
|
|
defer qt.Recovering("QStandardPaths::locateAll")
|
|
|
|
return strings.Split(C.GoString(C.QStandardPaths_QStandardPaths_LocateAll(C.int(ty), C.CString(fileName), C.int(options))), "|")
|
|
}
|
|
|
|
func QStandardPaths_DisplayName(ty QStandardPaths__StandardLocation) string {
|
|
defer qt.Recovering("QStandardPaths::displayName")
|
|
|
|
return C.GoString(C.QStandardPaths_QStandardPaths_DisplayName(C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QStandardPaths) DisplayName(ty QStandardPaths__StandardLocation) string {
|
|
defer qt.Recovering("QStandardPaths::displayName")
|
|
|
|
return C.GoString(C.QStandardPaths_QStandardPaths_DisplayName(C.int(ty)))
|
|
}
|
|
|
|
func QStandardPaths_StandardLocations(ty QStandardPaths__StandardLocation) []string {
|
|
defer qt.Recovering("QStandardPaths::standardLocations")
|
|
|
|
return strings.Split(C.GoString(C.QStandardPaths_QStandardPaths_StandardLocations(C.int(ty))), "|")
|
|
}
|
|
|
|
func (ptr *QStandardPaths) StandardLocations(ty QStandardPaths__StandardLocation) []string {
|
|
defer qt.Recovering("QStandardPaths::standardLocations")
|
|
|
|
return strings.Split(C.GoString(C.QStandardPaths_QStandardPaths_StandardLocations(C.int(ty))), "|")
|
|
}
|
|
|
|
func QStandardPaths_WritableLocation(ty QStandardPaths__StandardLocation) string {
|
|
defer qt.Recovering("QStandardPaths::writableLocation")
|
|
|
|
return C.GoString(C.QStandardPaths_QStandardPaths_WritableLocation(C.int(ty)))
|
|
}
|
|
|
|
func (ptr *QStandardPaths) WritableLocation(ty QStandardPaths__StandardLocation) string {
|
|
defer qt.Recovering("QStandardPaths::writableLocation")
|
|
|
|
return C.GoString(C.QStandardPaths_QStandardPaths_WritableLocation(C.int(ty)))
|
|
}
|
|
|
|
//QState::ChildMode
|
|
type QState__ChildMode int64
|
|
|
|
const (
|
|
QState__ExclusiveStates = QState__ChildMode(0)
|
|
QState__ParallelStates = QState__ChildMode(1)
|
|
)
|
|
|
|
//QState::RestorePolicy
|
|
type QState__RestorePolicy int64
|
|
|
|
const (
|
|
QState__DontRestoreProperties = QState__RestorePolicy(0)
|
|
QState__RestoreProperties = QState__RestorePolicy(1)
|
|
)
|
|
|
|
type QState struct {
|
|
QAbstractState
|
|
}
|
|
|
|
type QState_ITF interface {
|
|
QAbstractState_ITF
|
|
QState_PTR() *QState
|
|
}
|
|
|
|
func (p *QState) QState_PTR() *QState {
|
|
return p
|
|
}
|
|
|
|
func (p *QState) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractState_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QState) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractState_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQState(ptr QState_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QState_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQStateFromPointer(ptr unsafe.Pointer) *QState {
|
|
var n = new(QState)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQStateFromPointer(ptr unsafe.Pointer) *QState {
|
|
var n = NewQStateFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QState_") {
|
|
n.SetObjectName("QState_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQState2(childMode QState__ChildMode, parent QState_ITF) *QState {
|
|
defer qt.Recovering("QState::QState")
|
|
|
|
return newQStateFromPointer(C.QState_NewQState2(C.int(childMode), PointerFromQState(parent)))
|
|
}
|
|
|
|
func NewQState(parent QState_ITF) *QState {
|
|
defer qt.Recovering("QState::QState")
|
|
|
|
return newQStateFromPointer(C.QState_NewQState(PointerFromQState(parent)))
|
|
}
|
|
|
|
func (ptr *QState) AddTransition4(target QAbstractState_ITF) *QAbstractTransition {
|
|
defer qt.Recovering("QState::addTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractTransitionFromPointer(C.QState_AddTransition4(ptr.Pointer(), PointerFromQAbstractState(target)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QState) AddTransition2(sender QObject_ITF, sign string, target QAbstractState_ITF) *QSignalTransition {
|
|
defer qt.Recovering("QState::addTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSignalTransitionFromPointer(C.QState_AddTransition2(ptr.Pointer(), PointerFromQObject(sender), C.CString(sign), PointerFromQAbstractState(target)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QState) AddTransition(transition QAbstractTransition_ITF) {
|
|
defer qt.Recovering("QState::addTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_AddTransition(ptr.Pointer(), PointerFromQAbstractTransition(transition))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) AssignProperty(object QObject_ITF, name string, value QVariant_ITF) {
|
|
defer qt.Recovering("QState::assignProperty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_AssignProperty(ptr.Pointer(), PointerFromQObject(object), C.CString(name), PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ChildMode() QState__ChildMode {
|
|
defer qt.Recovering("QState::childMode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QState__ChildMode(C.QState_ChildMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQState_ChildModeChanged
|
|
func callbackQState_ChildModeChanged(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QState::childModeChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childModeChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QState) ConnectChildModeChanged(f func()) {
|
|
defer qt.Recovering("connect QState::childModeChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_ConnectChildModeChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "childModeChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectChildModeChanged() {
|
|
defer qt.Recovering("disconnect QState::childModeChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_DisconnectChildModeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childModeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ErrorState() *QAbstractState {
|
|
defer qt.Recovering("QState::errorState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractStateFromPointer(C.QState_ErrorState(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQState_ErrorStateChanged
|
|
func callbackQState_ErrorStateChanged(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QState::errorStateChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "errorStateChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QState) ConnectErrorStateChanged(f func()) {
|
|
defer qt.Recovering("connect QState::errorStateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_ConnectErrorStateChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "errorStateChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectErrorStateChanged() {
|
|
defer qt.Recovering("disconnect QState::errorStateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_DisconnectErrorStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "errorStateChanged")
|
|
}
|
|
}
|
|
|
|
//export callbackQState_Event
|
|
func callbackQState_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QState::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStateFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QState) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QState_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QState) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QState::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QState_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQState_Finished
|
|
func callbackQState_Finished(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QState::finished")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "finished"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QState) ConnectFinished(f func()) {
|
|
defer qt.Recovering("connect QState::finished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_ConnectFinished(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "finished", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectFinished() {
|
|
defer qt.Recovering("disconnect QState::finished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_DisconnectFinished(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "finished")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) InitialState() *QAbstractState {
|
|
defer qt.Recovering("QState::initialState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractStateFromPointer(C.QState_InitialState(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQState_InitialStateChanged
|
|
func callbackQState_InitialStateChanged(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QState::initialStateChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "initialStateChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QState) ConnectInitialStateChanged(f func()) {
|
|
defer qt.Recovering("connect QState::initialStateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_ConnectInitialStateChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "initialStateChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectInitialStateChanged() {
|
|
defer qt.Recovering("disconnect QState::initialStateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_DisconnectInitialStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "initialStateChanged")
|
|
}
|
|
}
|
|
|
|
//export callbackQState_OnEntry
|
|
func callbackQState_OnEntry(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QState::onEntry")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onEntry"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQStateFromPointer(ptr).OnEntryDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ConnectOnEntry(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onEntry", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectOnEntry() {
|
|
defer qt.Recovering("disconnect QState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onEntry")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) OnEntry(event QEvent_ITF) {
|
|
defer qt.Recovering("QState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) OnEntryDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QState::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_OnEntryDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQState_OnExit
|
|
func callbackQState_OnExit(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QState::onExit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onExit"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQStateFromPointer(ptr).OnExitDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ConnectOnExit(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onExit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectOnExit() {
|
|
defer qt.Recovering("disconnect QState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onExit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) OnExit(event QEvent_ITF) {
|
|
defer qt.Recovering("QState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_OnExit(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) OnExitDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QState::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_OnExitDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQState_PropertiesAssigned
|
|
func callbackQState_PropertiesAssigned(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QState::propertiesAssigned")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "propertiesAssigned"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QState) ConnectPropertiesAssigned(f func()) {
|
|
defer qt.Recovering("connect QState::propertiesAssigned")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_ConnectPropertiesAssigned(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "propertiesAssigned", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectPropertiesAssigned() {
|
|
defer qt.Recovering("disconnect QState::propertiesAssigned")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_DisconnectPropertiesAssigned(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "propertiesAssigned")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) RemoveTransition(transition QAbstractTransition_ITF) {
|
|
defer qt.Recovering("QState::removeTransition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_RemoveTransition(ptr.Pointer(), PointerFromQAbstractTransition(transition))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) SetChildMode(mode QState__ChildMode) {
|
|
defer qt.Recovering("QState::setChildMode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_SetChildMode(ptr.Pointer(), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) SetErrorState(state QAbstractState_ITF) {
|
|
defer qt.Recovering("QState::setErrorState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_SetErrorState(ptr.Pointer(), PointerFromQAbstractState(state))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) SetInitialState(state QAbstractState_ITF) {
|
|
defer qt.Recovering("QState::setInitialState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_SetInitialState(ptr.Pointer(), PointerFromQAbstractState(state))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DestroyQState() {
|
|
defer qt.Recovering("QState::~QState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QState_DestroyQState(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQState_TimerEvent
|
|
func callbackQState_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QState::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQStateFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QState::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQState_ChildEvent
|
|
func callbackQState_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QState::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQStateFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QState::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQState_ConnectNotify
|
|
func callbackQState_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QState::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQStateFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QState::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQState_CustomEvent
|
|
func callbackQState_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QState::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQStateFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QState::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQState_DeleteLater
|
|
func callbackQState_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QState::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQStateFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DeleteLater() {
|
|
defer qt.Recovering("QState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QState_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DeleteLaterDefault() {
|
|
defer qt.Recovering("QState::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QState_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQState_DisconnectNotify
|
|
func callbackQState_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QState::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQStateFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QState::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QState_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQState_EventFilter
|
|
func callbackQState_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QState::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStateFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QState) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QState_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QState) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QState::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QState_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQState_MetaObject
|
|
func callbackQState_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QState::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQStateFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QState) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QState) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QState_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QState) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QState::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QState_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//QStateMachine::Error
|
|
type QStateMachine__Error int64
|
|
|
|
const (
|
|
QStateMachine__NoError = QStateMachine__Error(0)
|
|
QStateMachine__NoInitialStateError = QStateMachine__Error(1)
|
|
QStateMachine__NoDefaultStateInHistoryStateError = QStateMachine__Error(2)
|
|
QStateMachine__NoCommonAncestorForTransitionError = QStateMachine__Error(3)
|
|
)
|
|
|
|
//QStateMachine::EventPriority
|
|
type QStateMachine__EventPriority int64
|
|
|
|
const (
|
|
QStateMachine__NormalPriority = QStateMachine__EventPriority(0)
|
|
QStateMachine__HighPriority = QStateMachine__EventPriority(1)
|
|
)
|
|
|
|
type QStateMachine struct {
|
|
QState
|
|
}
|
|
|
|
type QStateMachine_ITF interface {
|
|
QState_ITF
|
|
QStateMachine_PTR() *QStateMachine
|
|
}
|
|
|
|
func (p *QStateMachine) QStateMachine_PTR() *QStateMachine {
|
|
return p
|
|
}
|
|
|
|
func (p *QStateMachine) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QState_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QStateMachine) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QState_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQStateMachine(ptr QStateMachine_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QStateMachine_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQStateMachineFromPointer(ptr unsafe.Pointer) *QStateMachine {
|
|
var n = new(QStateMachine)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQStateMachineFromPointer(ptr unsafe.Pointer) *QStateMachine {
|
|
var n = NewQStateMachineFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QStateMachine_") {
|
|
n.SetObjectName("QStateMachine_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QStateMachine) IsRunning() bool {
|
|
defer qt.Recovering("QStateMachine::isRunning")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStateMachine_IsRunning(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStateMachine_SetRunning
|
|
func callbackQStateMachine_SetRunning(ptr unsafe.Pointer, ptrName *C.char, running C.int) {
|
|
defer qt.Recovering("callback QStateMachine::setRunning")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setRunning"); signal != nil {
|
|
signal.(func(bool))(int(running) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectSetRunning(f func(running bool)) {
|
|
defer qt.Recovering("connect QStateMachine::setRunning")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setRunning", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectSetRunning(running bool) {
|
|
defer qt.Recovering("disconnect QStateMachine::setRunning")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setRunning")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) SetRunning(running bool) {
|
|
defer qt.Recovering("QStateMachine::setRunning")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_SetRunning(ptr.Pointer(), C.int(qt.GoBoolToInt(running)))
|
|
}
|
|
}
|
|
|
|
func NewQStateMachine(parent QObject_ITF) *QStateMachine {
|
|
defer qt.Recovering("QStateMachine::QStateMachine")
|
|
|
|
return newQStateMachineFromPointer(C.QStateMachine_NewQStateMachine(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQStateMachine2(childMode QState__ChildMode, parent QObject_ITF) *QStateMachine {
|
|
defer qt.Recovering("QStateMachine::QStateMachine")
|
|
|
|
return newQStateMachineFromPointer(C.QStateMachine_NewQStateMachine2(C.int(childMode), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QStateMachine) AddDefaultAnimation(animation QAbstractAnimation_ITF) {
|
|
defer qt.Recovering("QStateMachine::addDefaultAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_AddDefaultAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) AddState(state QAbstractState_ITF) {
|
|
defer qt.Recovering("QStateMachine::addState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_AddState(ptr.Pointer(), PointerFromQAbstractState(state))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) CancelDelayedEvent(id int) bool {
|
|
defer qt.Recovering("QStateMachine::cancelDelayedEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStateMachine_CancelDelayedEvent(ptr.Pointer(), C.int(id)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStateMachine) ClearError() {
|
|
defer qt.Recovering("QStateMachine::clearError")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_ClearError(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) Error() QStateMachine__Error {
|
|
defer qt.Recovering("QStateMachine::error")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QStateMachine__Error(C.QStateMachine_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStateMachine) ErrorString() string {
|
|
defer qt.Recovering("QStateMachine::errorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStateMachine_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQStateMachine_Event
|
|
func callbackQStateMachine_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStateMachine::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStateMachineFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QStateMachine::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QStateMachine::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QStateMachine::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStateMachine_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStateMachine) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QStateMachine::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStateMachine_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStateMachine_EventFilter
|
|
func callbackQStateMachine_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStateMachine::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStateMachineFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QStateMachine::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QStateMachine::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QStateMachine::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStateMachine_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStateMachine) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QStateMachine::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStateMachine_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStateMachine) GlobalRestorePolicy() QState__RestorePolicy {
|
|
defer qt.Recovering("QStateMachine::globalRestorePolicy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QState__RestorePolicy(C.QStateMachine_GlobalRestorePolicy(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStateMachine) IsAnimated() bool {
|
|
defer qt.Recovering("QStateMachine::isAnimated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStateMachine_IsAnimated(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStateMachine_OnEntry
|
|
func callbackQStateMachine_OnEntry(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStateMachine::onEntry")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onEntry"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQStateMachineFromPointer(ptr).OnEntryDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectOnEntry(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QStateMachine::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onEntry", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectOnEntry() {
|
|
defer qt.Recovering("disconnect QStateMachine::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onEntry")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) OnEntry(event QEvent_ITF) {
|
|
defer qt.Recovering("QStateMachine::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) OnEntryDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QStateMachine::onEntry")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_OnEntryDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_OnExit
|
|
func callbackQStateMachine_OnExit(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStateMachine::onExit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "onExit"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQStateMachineFromPointer(ptr).OnExitDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectOnExit(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QStateMachine::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "onExit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectOnExit() {
|
|
defer qt.Recovering("disconnect QStateMachine::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "onExit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) OnExit(event QEvent_ITF) {
|
|
defer qt.Recovering("QStateMachine::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_OnExit(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) OnExitDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QStateMachine::onExit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_OnExitDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) PostDelayedEvent(event QEvent_ITF, delay int) int {
|
|
defer qt.Recovering("QStateMachine::postDelayedEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStateMachine_PostDelayedEvent(ptr.Pointer(), PointerFromQEvent(event), C.int(delay)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStateMachine) PostEvent(event QEvent_ITF, priority QStateMachine__EventPriority) {
|
|
defer qt.Recovering("QStateMachine::postEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_PostEvent(ptr.Pointer(), PointerFromQEvent(event), C.int(priority))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) RemoveDefaultAnimation(animation QAbstractAnimation_ITF) {
|
|
defer qt.Recovering("QStateMachine::removeDefaultAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_RemoveDefaultAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) RemoveState(state QAbstractState_ITF) {
|
|
defer qt.Recovering("QStateMachine::removeState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_RemoveState(ptr.Pointer(), PointerFromQAbstractState(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_RunningChanged
|
|
func callbackQStateMachine_RunningChanged(ptr unsafe.Pointer, ptrName *C.char, running C.int) {
|
|
defer qt.Recovering("callback QStateMachine::runningChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "runningChanged"); signal != nil {
|
|
signal.(func(bool))(int(running) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectRunningChanged(f func(running bool)) {
|
|
defer qt.Recovering("connect QStateMachine::runningChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_ConnectRunningChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "runningChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectRunningChanged() {
|
|
defer qt.Recovering("disconnect QStateMachine::runningChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_DisconnectRunningChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "runningChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) RunningChanged(running bool) {
|
|
defer qt.Recovering("QStateMachine::runningChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_RunningChanged(ptr.Pointer(), C.int(qt.GoBoolToInt(running)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) SetAnimated(enabled bool) {
|
|
defer qt.Recovering("QStateMachine::setAnimated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_SetAnimated(ptr.Pointer(), C.int(qt.GoBoolToInt(enabled)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) SetGlobalRestorePolicy(restorePolicy QState__RestorePolicy) {
|
|
defer qt.Recovering("QStateMachine::setGlobalRestorePolicy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_SetGlobalRestorePolicy(ptr.Pointer(), C.int(restorePolicy))
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_Start
|
|
func callbackQStateMachine_Start(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QStateMachine::start")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "start"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectStart(f func()) {
|
|
defer qt.Recovering("connect QStateMachine::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "start", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectStart() {
|
|
defer qt.Recovering("disconnect QStateMachine::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) Start() {
|
|
defer qt.Recovering("QStateMachine::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_Start(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_Started
|
|
func callbackQStateMachine_Started(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QStateMachine::started")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "started"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectStarted(f func()) {
|
|
defer qt.Recovering("connect QStateMachine::started")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_ConnectStarted(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "started", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectStarted() {
|
|
defer qt.Recovering("disconnect QStateMachine::started")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_DisconnectStarted(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "started")
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_Stop
|
|
func callbackQStateMachine_Stop(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QStateMachine::stop")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stop"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectStop(f func()) {
|
|
defer qt.Recovering("connect QStateMachine::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "stop", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectStop() {
|
|
defer qt.Recovering("disconnect QStateMachine::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) Stop() {
|
|
defer qt.Recovering("QStateMachine::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_Stopped
|
|
func callbackQStateMachine_Stopped(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QStateMachine::stopped")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stopped"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectStopped(f func()) {
|
|
defer qt.Recovering("connect QStateMachine::stopped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_ConnectStopped(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "stopped", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectStopped() {
|
|
defer qt.Recovering("disconnect QStateMachine::stopped")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_DisconnectStopped(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stopped")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DestroyQStateMachine() {
|
|
defer qt.Recovering("QStateMachine::~QStateMachine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QStateMachine_DestroyQStateMachine(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_TimerEvent
|
|
func callbackQStateMachine_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStateMachine::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQStateMachineFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QStateMachine::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QStateMachine::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QStateMachine::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QStateMachine::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_ChildEvent
|
|
func callbackQStateMachine_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStateMachine::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQStateMachineFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QStateMachine::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QStateMachine::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QStateMachine::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QStateMachine::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_ConnectNotify
|
|
func callbackQStateMachine_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStateMachine::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQStateMachineFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QStateMachine::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QStateMachine::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QStateMachine::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QStateMachine::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_CustomEvent
|
|
func callbackQStateMachine_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStateMachine::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQStateMachineFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QStateMachine::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QStateMachine::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QStateMachine::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QStateMachine::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_DeleteLater
|
|
func callbackQStateMachine_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QStateMachine::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQStateMachineFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QStateMachine::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QStateMachine::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DeleteLater() {
|
|
defer qt.Recovering("QStateMachine::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QStateMachine_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DeleteLaterDefault() {
|
|
defer qt.Recovering("QStateMachine::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QStateMachine_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_DisconnectNotify
|
|
func callbackQStateMachine_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStateMachine::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQStateMachineFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QStateMachine::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QStateMachine::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QStateMachine::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QStateMachine::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStateMachine_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQStateMachine_MetaObject
|
|
func callbackQStateMachine_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QStateMachine::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQStateMachineFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QStateMachine) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QStateMachine::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QStateMachine::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStateMachine) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QStateMachine::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QStateMachine_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStateMachine) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QStateMachine::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QStateMachine_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QStaticPlugin struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QStaticPlugin_ITF interface {
|
|
QStaticPlugin_PTR() *QStaticPlugin
|
|
}
|
|
|
|
func (p *QStaticPlugin) QStaticPlugin_PTR() *QStaticPlugin {
|
|
return p
|
|
}
|
|
|
|
func (p *QStaticPlugin) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QStaticPlugin) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQStaticPlugin(ptr QStaticPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QStaticPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQStaticPluginFromPointer(ptr unsafe.Pointer) *QStaticPlugin {
|
|
var n = new(QStaticPlugin)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQStaticPluginFromPointer(ptr unsafe.Pointer) *QStaticPlugin {
|
|
var n = NewQStaticPluginFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QStaticPlugin) Instance() *QObject {
|
|
defer qt.Recovering("QStaticPlugin::instance")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQObjectFromPointer(C.QStaticPlugin_Instance(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStaticPlugin) MetaData() *QJsonObject {
|
|
defer qt.Recovering("QStaticPlugin::metaData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonObjectFromPointer(C.QStaticPlugin_MetaData(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStaticPlugin) RawMetaData() string {
|
|
defer qt.Recovering("QStaticPlugin::rawMetaData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStaticPlugin_RawMetaData(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type QStorageInfo struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QStorageInfo_ITF interface {
|
|
QStorageInfo_PTR() *QStorageInfo
|
|
}
|
|
|
|
func (p *QStorageInfo) QStorageInfo_PTR() *QStorageInfo {
|
|
return p
|
|
}
|
|
|
|
func (p *QStorageInfo) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QStorageInfo) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQStorageInfo(ptr QStorageInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QStorageInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQStorageInfoFromPointer(ptr unsafe.Pointer) *QStorageInfo {
|
|
var n = new(QStorageInfo)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQStorageInfoFromPointer(ptr unsafe.Pointer) *QStorageInfo {
|
|
var n = NewQStorageInfoFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQStorageInfo() *QStorageInfo {
|
|
defer qt.Recovering("QStorageInfo::QStorageInfo")
|
|
|
|
return newQStorageInfoFromPointer(C.QStorageInfo_NewQStorageInfo())
|
|
}
|
|
|
|
func NewQStorageInfo3(dir QDir_ITF) *QStorageInfo {
|
|
defer qt.Recovering("QStorageInfo::QStorageInfo")
|
|
|
|
return newQStorageInfoFromPointer(C.QStorageInfo_NewQStorageInfo3(PointerFromQDir(dir)))
|
|
}
|
|
|
|
func NewQStorageInfo4(other QStorageInfo_ITF) *QStorageInfo {
|
|
defer qt.Recovering("QStorageInfo::QStorageInfo")
|
|
|
|
return newQStorageInfoFromPointer(C.QStorageInfo_NewQStorageInfo4(PointerFromQStorageInfo(other)))
|
|
}
|
|
|
|
func NewQStorageInfo2(path string) *QStorageInfo {
|
|
defer qt.Recovering("QStorageInfo::QStorageInfo")
|
|
|
|
return newQStorageInfoFromPointer(C.QStorageInfo_NewQStorageInfo2(C.CString(path)))
|
|
}
|
|
|
|
func (ptr *QStorageInfo) BlockSize() int {
|
|
defer qt.Recovering("QStorageInfo::blockSize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStorageInfo_BlockSize(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStorageInfo) BytesAvailable() int64 {
|
|
defer qt.Recovering("QStorageInfo::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QStorageInfo_BytesAvailable(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStorageInfo) BytesFree() int64 {
|
|
defer qt.Recovering("QStorageInfo::bytesFree")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QStorageInfo_BytesFree(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStorageInfo) BytesTotal() int64 {
|
|
defer qt.Recovering("QStorageInfo::bytesTotal")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QStorageInfo_BytesTotal(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStorageInfo) Device() string {
|
|
defer qt.Recovering("QStorageInfo::device")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStorageInfo_Device(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QStorageInfo) DisplayName() string {
|
|
defer qt.Recovering("QStorageInfo::displayName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStorageInfo_DisplayName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QStorageInfo) FileSystemType() string {
|
|
defer qt.Recovering("QStorageInfo::fileSystemType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStorageInfo_FileSystemType(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QStorageInfo) IsReadOnly() bool {
|
|
defer qt.Recovering("QStorageInfo::isReadOnly")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStorageInfo_IsReadOnly(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStorageInfo) IsReady() bool {
|
|
defer qt.Recovering("QStorageInfo::isReady")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStorageInfo_IsReady(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStorageInfo) IsRoot() bool {
|
|
defer qt.Recovering("QStorageInfo::isRoot")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStorageInfo_IsRoot(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStorageInfo) IsValid() bool {
|
|
defer qt.Recovering("QStorageInfo::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStorageInfo_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStorageInfo) Name() string {
|
|
defer qt.Recovering("QStorageInfo::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStorageInfo_Name(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QStorageInfo) Refresh() {
|
|
defer qt.Recovering("QStorageInfo::refresh")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStorageInfo_Refresh(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func QStorageInfo_Root() *QStorageInfo {
|
|
defer qt.Recovering("QStorageInfo::root")
|
|
|
|
return NewQStorageInfoFromPointer(C.QStorageInfo_QStorageInfo_Root())
|
|
}
|
|
|
|
func (ptr *QStorageInfo) Root() *QStorageInfo {
|
|
defer qt.Recovering("QStorageInfo::root")
|
|
|
|
return NewQStorageInfoFromPointer(C.QStorageInfo_QStorageInfo_Root())
|
|
}
|
|
|
|
func (ptr *QStorageInfo) RootPath() string {
|
|
defer qt.Recovering("QStorageInfo::rootPath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStorageInfo_RootPath(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QStorageInfo) SetPath(path string) {
|
|
defer qt.Recovering("QStorageInfo::setPath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStorageInfo_SetPath(ptr.Pointer(), C.CString(path))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStorageInfo) Swap(other QStorageInfo_ITF) {
|
|
defer qt.Recovering("QStorageInfo::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStorageInfo_Swap(ptr.Pointer(), PointerFromQStorageInfo(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStorageInfo) DestroyQStorageInfo() {
|
|
defer qt.Recovering("QStorageInfo::~QStorageInfo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStorageInfo_DestroyQStorageInfo(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QString::NormalizationForm
|
|
type QString__NormalizationForm int64
|
|
|
|
const (
|
|
QString__NormalizationForm_D = QString__NormalizationForm(0)
|
|
QString__NormalizationForm_C = QString__NormalizationForm(1)
|
|
QString__NormalizationForm_KD = QString__NormalizationForm(2)
|
|
QString__NormalizationForm_KC = QString__NormalizationForm(3)
|
|
)
|
|
|
|
//QString::SectionFlag
|
|
type QString__SectionFlag int64
|
|
|
|
const (
|
|
QString__SectionDefault = QString__SectionFlag(0x00)
|
|
QString__SectionSkipEmpty = QString__SectionFlag(0x01)
|
|
QString__SectionIncludeLeadingSep = QString__SectionFlag(0x02)
|
|
QString__SectionIncludeTrailingSep = QString__SectionFlag(0x04)
|
|
QString__SectionCaseInsensitiveSeps = QString__SectionFlag(0x08)
|
|
)
|
|
|
|
//QString::SplitBehavior
|
|
type QString__SplitBehavior int64
|
|
|
|
const (
|
|
QString__KeepEmptyParts = QString__SplitBehavior(0)
|
|
QString__SkipEmptyParts = QString__SplitBehavior(1)
|
|
)
|
|
|
|
type QString struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QString_ITF interface {
|
|
QString_PTR() *QString
|
|
}
|
|
|
|
func (p *QString) QString_PTR() *QString {
|
|
return p
|
|
}
|
|
|
|
func (p *QString) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QString) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQString(ptr QString_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QString_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQStringFromPointer(ptr unsafe.Pointer) *QString {
|
|
var n = new(QString)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQStringFromPointer(ptr unsafe.Pointer) *QString {
|
|
var n = NewQStringFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QStringList struct {
|
|
QList
|
|
}
|
|
|
|
type QStringList_ITF interface {
|
|
QList_ITF
|
|
QStringList_PTR() *QStringList
|
|
}
|
|
|
|
func (p *QStringList) QStringList_PTR() *QStringList {
|
|
return p
|
|
}
|
|
|
|
func (p *QStringList) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QList_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QStringList) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QList_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQStringList(ptr QStringList_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QStringList_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQStringListFromPointer(ptr unsafe.Pointer) *QStringList {
|
|
var n = new(QStringList)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQStringListFromPointer(ptr unsafe.Pointer) *QStringList {
|
|
var n = NewQStringListFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QStringListModel struct {
|
|
QAbstractListModel
|
|
}
|
|
|
|
type QStringListModel_ITF interface {
|
|
QAbstractListModel_ITF
|
|
QStringListModel_PTR() *QStringListModel
|
|
}
|
|
|
|
func (p *QStringListModel) QStringListModel_PTR() *QStringListModel {
|
|
return p
|
|
}
|
|
|
|
func (p *QStringListModel) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractListModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QStringListModel) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractListModel_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQStringListModel(ptr QStringListModel_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QStringListModel_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQStringListModelFromPointer(ptr unsafe.Pointer) *QStringListModel {
|
|
var n = new(QStringListModel)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQStringListModelFromPointer(ptr unsafe.Pointer) *QStringListModel {
|
|
var n = NewQStringListModelFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QStringListModel_") {
|
|
n.SetObjectName("QStringListModel_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQStringListModel(parent QObject_ITF) *QStringListModel {
|
|
defer qt.Recovering("QStringListModel::QStringListModel")
|
|
|
|
return newQStringListModelFromPointer(C.QStringListModel_NewQStringListModel(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQStringListModel2(strin []string, parent QObject_ITF) *QStringListModel {
|
|
defer qt.Recovering("QStringListModel::QStringListModel")
|
|
|
|
return newQStringListModelFromPointer(C.QStringListModel_NewQStringListModel2(C.CString(strings.Join(strin, "|")), PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQStringListModel_Data
|
|
func callbackQStringListModel_Data(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QStringListModel::data")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "data"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(*QModelIndex, int) *QVariant)(NewQModelIndexFromPointer(index), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQStringListModelFromPointer(ptr).DataDefault(NewQModelIndexFromPointer(index), int(role)))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectData(f func(index *QModelIndex, role int) *QVariant) {
|
|
defer qt.Recovering("connect QStringListModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "data", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectData() {
|
|
defer qt.Recovering("disconnect QStringListModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "data")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) Data(index QModelIndex_ITF, role int) *QVariant {
|
|
defer qt.Recovering("QStringListModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QStringListModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringListModel) DataDefault(index QModelIndex_ITF, role int) *QVariant {
|
|
defer qt.Recovering("QStringListModel::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QStringListModel_DataDefault(ptr.Pointer(), PointerFromQModelIndex(index), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQStringListModel_Flags
|
|
func callbackQStringListModel_Flags(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::flags")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "flags"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) Qt__ItemFlag)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return C.int(NewQStringListModelFromPointer(ptr).FlagsDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectFlags(f func(index *QModelIndex) Qt__ItemFlag) {
|
|
defer qt.Recovering("connect QStringListModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "flags", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectFlags() {
|
|
defer qt.Recovering("disconnect QStringListModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "flags")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QStringListModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QStringListModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringListModel) FlagsDefault(index QModelIndex_ITF) Qt__ItemFlag {
|
|
defer qt.Recovering("QStringListModel::flags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__ItemFlag(C.QStringListModel_FlagsDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQStringListModel_InsertRows
|
|
func callbackQStringListModel_InsertRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::insertRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).InsertRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectInsertRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QStringListModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectInsertRows() {
|
|
defer qt.Recovering("disconnect QStringListModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) InsertRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_InsertRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) InsertRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::insertRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_InsertRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_RemoveRows
|
|
func callbackQStringListModel_RemoveRows(ptr unsafe.Pointer, ptrName *C.char, row C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::removeRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).RemoveRowsDefault(int(row), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectRemoveRows(f func(row int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QStringListModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectRemoveRows() {
|
|
defer qt.Recovering("disconnect QStringListModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) RemoveRows(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_RemoveRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) RemoveRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::removeRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_RemoveRowsDefault(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_RowCount
|
|
func callbackQStringListModel_RowCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::rowCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "rowCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(NewQStringListModelFromPointer(ptr).RowCountDefault(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectRowCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QStringListModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "rowCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectRowCount() {
|
|
defer qt.Recovering("disconnect QStringListModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "rowCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) RowCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QStringListModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringListModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringListModel) RowCountDefault(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QStringListModel::rowCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringListModel_RowCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQStringListModel_SetData
|
|
func callbackQStringListModel_SetData(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QStringListModel::setData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, *QVariant, int) bool)(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).SetDataDefault(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectSetData(f func(index *QModelIndex, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QStringListModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectSetData() {
|
|
defer qt.Recovering("disconnect QStringListModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) SetData(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QStringListModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_SetData(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) SetDataDefault(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QStringListModel::setData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_SetDataDefault(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) SetStringList(strin []string) {
|
|
defer qt.Recovering("QStringListModel::setStringList")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_SetStringList(ptr.Pointer(), C.CString(strings.Join(strin, "|")))
|
|
}
|
|
}
|
|
|
|
//export callbackQStringListModel_Sibling
|
|
func callbackQStringListModel_Sibling(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, idx unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QStringListModel::sibling")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sibling"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(idx)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQStringListModelFromPointer(ptr).SiblingDefault(int(row), int(column), NewQModelIndexFromPointer(idx)))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectSibling(f func(row int, column int, idx *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QStringListModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sibling", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectSibling() {
|
|
defer qt.Recovering("disconnect QStringListModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sibling")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) Sibling(row int, column int, idx QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QStringListModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QStringListModel_Sibling(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringListModel) SiblingDefault(row int, column int, idx QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QStringListModel::sibling")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QStringListModel_SiblingDefault(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(idx)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQStringListModel_Sort
|
|
func callbackQStringListModel_Sort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
|
|
defer qt.Recovering("callback QStringListModel::sort")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
|
|
signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
|
|
} else {
|
|
NewQStringListModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
|
|
defer qt.Recovering("connect QStringListModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "sort", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectSort() {
|
|
defer qt.Recovering("disconnect QStringListModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "sort")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) Sort(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QStringListModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) SortDefault(column int, order Qt__SortOrder) {
|
|
defer qt.Recovering("QStringListModel::sort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) StringList() []string {
|
|
defer qt.Recovering("QStringListModel::stringList")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QStringListModel_StringList(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQStringListModel_SupportedDropActions
|
|
func callbackQStringListModel_SupportedDropActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QStringListModel::supportedDropActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDropActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQStringListModelFromPointer(ptr).SupportedDropActionsDefault())
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectSupportedDropActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QStringListModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDropActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectSupportedDropActions() {
|
|
defer qt.Recovering("disconnect QStringListModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDropActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) SupportedDropActions() Qt__DropAction {
|
|
defer qt.Recovering("QStringListModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QStringListModel_SupportedDropActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringListModel) SupportedDropActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QStringListModel::supportedDropActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QStringListModel_SupportedDropActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQStringListModel_Index
|
|
func callbackQStringListModel_Index(ptr unsafe.Pointer, ptrName *C.char, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QStringListModel::index")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "index"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(int, int, *QModelIndex) *QModelIndex)(int(row), int(column), NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQStringListModelFromPointer(ptr).IndexDefault(int(row), int(column), NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QStringListModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "index", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectIndex() {
|
|
defer qt.Recovering("disconnect QStringListModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "index")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QStringListModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QStringListModel_Index(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringListModel) IndexDefault(row int, column int, parent QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QStringListModel::index")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QStringListModel_IndexDefault(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQStringListModel_DropMimeData
|
|
func callbackQStringListModel_DropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::dropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "dropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).DropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QStringListModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "dropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectDropMimeData() {
|
|
defer qt.Recovering("disconnect QStringListModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "dropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) DropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::dropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_DropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_Buddy
|
|
func callbackQStringListModel_Buddy(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QStringListModel::buddy")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "buddy"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQStringListModelFromPointer(ptr).BuddyDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectBuddy(f func(index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QStringListModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "buddy", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectBuddy() {
|
|
defer qt.Recovering("disconnect QStringListModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "buddy")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) Buddy(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QStringListModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QStringListModel_Buddy(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringListModel) BuddyDefault(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QStringListModel::buddy")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QStringListModel_BuddyDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQStringListModel_CanDropMimeData
|
|
func callbackQStringListModel_CanDropMimeData(ptr unsafe.Pointer, ptrName *C.char, data unsafe.Pointer, action C.int, row C.int, column C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::canDropMimeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canDropMimeData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).CanDropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(row), int(column), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectCanDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QStringListModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canDropMimeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectCanDropMimeData() {
|
|
defer qt.Recovering("disconnect QStringListModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canDropMimeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) CanDropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_CanDropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) CanDropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::canDropMimeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_CanDropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_CanFetchMore
|
|
func callbackQStringListModel_CanFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::canFetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canFetchMore"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).CanFetchMoreDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectCanFetchMore(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QStringListModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canFetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectCanFetchMore() {
|
|
defer qt.Recovering("disconnect QStringListModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canFetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) CanFetchMore(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_CanFetchMore(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) CanFetchMoreDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::canFetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_CanFetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_ColumnCount
|
|
func callbackQStringListModel_ColumnCount(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::columnCount")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "columnCount"); signal != nil {
|
|
return C.int(signal.(func(*QModelIndex) int)(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
return C.int(NewQStringListModelFromPointer(ptr).ColumnCountDefault(NewQModelIndexFromPointer(parent)))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectColumnCount(f func(parent *QModelIndex) int) {
|
|
defer qt.Recovering("connect QStringListModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "columnCount", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectColumnCount() {
|
|
defer qt.Recovering("disconnect QStringListModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "columnCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ColumnCount(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QStringListModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringListModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringListModel) ColumnCountDefault(parent QModelIndex_ITF) int {
|
|
defer qt.Recovering("QStringListModel::columnCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringListModel_ColumnCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQStringListModel_FetchMore
|
|
func callbackQStringListModel_FetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStringListModel::fetchMore")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
|
|
signal.(func(*QModelIndex))(NewQModelIndexFromPointer(parent))
|
|
} else {
|
|
NewQStringListModelFromPointer(ptr).FetchMoreDefault(NewQModelIndexFromPointer(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectFetchMore(f func(parent *QModelIndex)) {
|
|
defer qt.Recovering("connect QStringListModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectFetchMore() {
|
|
defer qt.Recovering("disconnect QStringListModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) FetchMore(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QStringListModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_FetchMore(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) FetchMoreDefault(parent QModelIndex_ITF) {
|
|
defer qt.Recovering("QStringListModel::fetchMore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_FetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent))
|
|
}
|
|
}
|
|
|
|
//export callbackQStringListModel_HasChildren
|
|
func callbackQStringListModel_HasChildren(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::hasChildren")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "hasChildren"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex) bool)(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).HasChildrenDefault(NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectHasChildren(f func(parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QStringListModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "hasChildren", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectHasChildren() {
|
|
defer qt.Recovering("disconnect QStringListModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "hasChildren")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) HasChildren(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_HasChildren(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) HasChildrenDefault(parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::hasChildren")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_HasChildrenDefault(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_HeaderData
|
|
func callbackQStringListModel_HeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, role C.int) unsafe.Pointer {
|
|
defer qt.Recovering("callback QStringListModel::headerData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "headerData"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(int, Qt__Orientation, int) *QVariant)(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQStringListModelFromPointer(ptr).HeaderDataDefault(int(section), Qt__Orientation(orientation), int(role)))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectHeaderData(f func(section int, orientation Qt__Orientation, role int) *QVariant) {
|
|
defer qt.Recovering("connect QStringListModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "headerData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectHeaderData() {
|
|
defer qt.Recovering("disconnect QStringListModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "headerData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) HeaderData(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QStringListModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QStringListModel_HeaderData(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringListModel) HeaderDataDefault(section int, orientation Qt__Orientation, role int) *QVariant {
|
|
defer qt.Recovering("QStringListModel::headerData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QStringListModel_HeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQStringListModel_InsertColumns
|
|
func callbackQStringListModel_InsertColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::insertColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "insertColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).InsertColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectInsertColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QStringListModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "insertColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectInsertColumns() {
|
|
defer qt.Recovering("disconnect QStringListModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "insertColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) InsertColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_InsertColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) InsertColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::insertColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_InsertColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_MimeTypes
|
|
func callbackQStringListModel_MimeTypes(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QStringListModel::mimeTypes")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mimeTypes"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(NewQStringListModelFromPointer(ptr).MimeTypesDefault(), "|"))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectMimeTypes(f func() []string) {
|
|
defer qt.Recovering("connect QStringListModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "mimeTypes", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectMimeTypes() {
|
|
defer qt.Recovering("disconnect QStringListModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "mimeTypes")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) MimeTypes() []string {
|
|
defer qt.Recovering("QStringListModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QStringListModel_MimeTypes(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QStringListModel) MimeTypesDefault() []string {
|
|
defer qt.Recovering("QStringListModel::mimeTypes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QStringListModel_MimeTypesDefault(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQStringListModel_MoveColumns
|
|
func callbackQStringListModel_MoveColumns(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceColumn C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QStringListModel::moveColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).MoveColumnsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceColumn), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectMoveColumns(f func(sourceParent *QModelIndex, sourceColumn int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QStringListModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectMoveColumns() {
|
|
defer qt.Recovering("disconnect QStringListModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) MoveColumns(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QStringListModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_MoveColumns(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) MoveColumnsDefault(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QStringListModel::moveColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_MoveColumnsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_MoveRows
|
|
func callbackQStringListModel_MoveRows(ptr unsafe.Pointer, ptrName *C.char, sourceParent unsafe.Pointer, sourceRow C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.int {
|
|
defer qt.Recovering("callback QStringListModel::moveRows")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "moveRows"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QModelIndex, int, int, *QModelIndex, int) bool)(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).MoveRowsDefault(NewQModelIndexFromPointer(sourceParent), int(sourceRow), int(count), NewQModelIndexFromPointer(destinationParent), int(destinationChild))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectMoveRows(f func(sourceParent *QModelIndex, sourceRow int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
|
|
defer qt.Recovering("connect QStringListModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "moveRows", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectMoveRows() {
|
|
defer qt.Recovering("disconnect QStringListModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "moveRows")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) MoveRows(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QStringListModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_MoveRows(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) MoveRowsDefault(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
|
|
defer qt.Recovering("QStringListModel::moveRows")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_MoveRowsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_Parent
|
|
func callbackQStringListModel_Parent(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QStringListModel::parent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "parent"); signal != nil {
|
|
return PointerFromQModelIndex(signal.(func(*QModelIndex) *QModelIndex)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQModelIndex(NewQStringListModelFromPointer(ptr).ParentDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectParent(f func(index *QModelIndex) *QModelIndex) {
|
|
defer qt.Recovering("connect QStringListModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "parent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectParent() {
|
|
defer qt.Recovering("disconnect QStringListModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "parent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) Parent(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QStringListModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QStringListModel_Parent(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringListModel) ParentDefault(index QModelIndex_ITF) *QModelIndex {
|
|
defer qt.Recovering("QStringListModel::parent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QStringListModel_ParentDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQStringListModel_RemoveColumns
|
|
func callbackQStringListModel_RemoveColumns(ptr unsafe.Pointer, ptrName *C.char, column C.int, count C.int, parent unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::removeColumns")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "removeColumns"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, int, *QModelIndex) bool)(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).RemoveColumnsDefault(int(column), int(count), NewQModelIndexFromPointer(parent))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectRemoveColumns(f func(column int, count int, parent *QModelIndex) bool) {
|
|
defer qt.Recovering("connect QStringListModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "removeColumns", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectRemoveColumns() {
|
|
defer qt.Recovering("disconnect QStringListModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "removeColumns")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) RemoveColumns(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_RemoveColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) RemoveColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::removeColumns")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_RemoveColumnsDefault(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_ResetInternalData
|
|
func callbackQStringListModel_ResetInternalData(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QStringListModel::resetInternalData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resetInternalData"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQStringListModelFromPointer(ptr).ResetInternalDataDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectResetInternalData(f func()) {
|
|
defer qt.Recovering("connect QStringListModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resetInternalData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectResetInternalData() {
|
|
defer qt.Recovering("disconnect QStringListModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resetInternalData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ResetInternalData() {
|
|
defer qt.Recovering("QStringListModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_ResetInternalData(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ResetInternalDataDefault() {
|
|
defer qt.Recovering("QStringListModel::resetInternalData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_ResetInternalDataDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQStringListModel_Revert
|
|
func callbackQStringListModel_Revert(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QStringListModel::revert")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQStringListModelFromPointer(ptr).RevertDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectRevert(f func()) {
|
|
defer qt.Recovering("connect QStringListModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "revert", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectRevert() {
|
|
defer qt.Recovering("disconnect QStringListModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "revert")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) Revert() {
|
|
defer qt.Recovering("QStringListModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_Revert(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) RevertDefault() {
|
|
defer qt.Recovering("QStringListModel::revert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_RevertDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQStringListModel_SetHeaderData
|
|
func callbackQStringListModel_SetHeaderData(ptr unsafe.Pointer, ptrName *C.char, section C.int, orientation C.int, value unsafe.Pointer, role C.int) C.int {
|
|
defer qt.Recovering("callback QStringListModel::setHeaderData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setHeaderData"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int, Qt__Orientation, *QVariant, int) bool)(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).SetHeaderDataDefault(int(section), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(role))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectSetHeaderData(f func(section int, orientation Qt__Orientation, value *QVariant, role int) bool) {
|
|
defer qt.Recovering("connect QStringListModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setHeaderData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectSetHeaderData() {
|
|
defer qt.Recovering("disconnect QStringListModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setHeaderData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) SetHeaderData(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QStringListModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_SetHeaderData(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) SetHeaderDataDefault(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
|
|
defer qt.Recovering("QStringListModel::setHeaderData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_SetHeaderDataDefault(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_Span
|
|
func callbackQStringListModel_Span(ptr unsafe.Pointer, ptrName *C.char, index unsafe.Pointer) unsafe.Pointer {
|
|
defer qt.Recovering("callback QStringListModel::span")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "span"); signal != nil {
|
|
return PointerFromQSize(signal.(func(*QModelIndex) *QSize)(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
return PointerFromQSize(NewQStringListModelFromPointer(ptr).SpanDefault(NewQModelIndexFromPointer(index)))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectSpan(f func(index *QModelIndex) *QSize) {
|
|
defer qt.Recovering("connect QStringListModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "span", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectSpan() {
|
|
defer qt.Recovering("disconnect QStringListModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "span")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) Span(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QStringListModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QStringListModel_Span(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringListModel) SpanDefault(index QModelIndex_ITF) *QSize {
|
|
defer qt.Recovering("QStringListModel::span")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QStringListModel_SpanDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQStringListModel_Submit
|
|
func callbackQStringListModel_Submit(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QStringListModel::submit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "submit"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).SubmitDefault()))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectSubmit(f func() bool) {
|
|
defer qt.Recovering("connect QStringListModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "submit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectSubmit() {
|
|
defer qt.Recovering("disconnect QStringListModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "submit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) Submit() bool {
|
|
defer qt.Recovering("QStringListModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_Submit(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) SubmitDefault() bool {
|
|
defer qt.Recovering("QStringListModel::submit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_SubmitDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_SupportedDragActions
|
|
func callbackQStringListModel_SupportedDragActions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QStringListModel::supportedDragActions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "supportedDragActions"); signal != nil {
|
|
return C.int(signal.(func() Qt__DropAction)())
|
|
}
|
|
|
|
return C.int(NewQStringListModelFromPointer(ptr).SupportedDragActionsDefault())
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectSupportedDragActions(f func() Qt__DropAction) {
|
|
defer qt.Recovering("connect QStringListModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "supportedDragActions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectSupportedDragActions() {
|
|
defer qt.Recovering("disconnect QStringListModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "supportedDragActions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) SupportedDragActions() Qt__DropAction {
|
|
defer qt.Recovering("QStringListModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QStringListModel_SupportedDragActions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringListModel) SupportedDragActionsDefault() Qt__DropAction {
|
|
defer qt.Recovering("QStringListModel::supportedDragActions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__DropAction(C.QStringListModel_SupportedDragActionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQStringListModel_TimerEvent
|
|
func callbackQStringListModel_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStringListModel::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQStringListModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QStringListModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QStringListModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QStringListModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QStringListModel::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQStringListModel_ChildEvent
|
|
func callbackQStringListModel_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStringListModel::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQStringListModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QStringListModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QStringListModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QStringListModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QStringListModel::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQStringListModel_ConnectNotify
|
|
func callbackQStringListModel_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStringListModel::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQStringListModelFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QStringListModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QStringListModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QStringListModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QStringListModel::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQStringListModel_CustomEvent
|
|
func callbackQStringListModel_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStringListModel::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQStringListModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QStringListModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QStringListModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QStringListModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QStringListModel::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQStringListModel_DeleteLater
|
|
func callbackQStringListModel_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QStringListModel::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQStringListModelFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QStringListModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QStringListModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DeleteLater() {
|
|
defer qt.Recovering("QStringListModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QStringListModel_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DeleteLaterDefault() {
|
|
defer qt.Recovering("QStringListModel::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QStringListModel_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQStringListModel_DisconnectNotify
|
|
func callbackQStringListModel_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QStringListModel::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQStringListModelFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QStringListModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QStringListModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QStringListModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QStringListModel::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringListModel_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQStringListModel_Event
|
|
func callbackQStringListModel_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QStringListModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QStringListModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_EventFilter
|
|
func callbackQStringListModel_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QStringListModel::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQStringListModelFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QStringListModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QStringListModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringListModel) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QStringListModel::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringListModel_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQStringListModel_MetaObject
|
|
func callbackQStringListModel_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QStringListModel::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQStringListModelFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QStringListModel) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QStringListModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QStringListModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringListModel) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QStringListModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QStringListModel_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringListModel) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QStringListModel::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QStringListModel_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QStringMatcher struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QStringMatcher_ITF interface {
|
|
QStringMatcher_PTR() *QStringMatcher
|
|
}
|
|
|
|
func (p *QStringMatcher) QStringMatcher_PTR() *QStringMatcher {
|
|
return p
|
|
}
|
|
|
|
func (p *QStringMatcher) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QStringMatcher) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQStringMatcher(ptr QStringMatcher_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QStringMatcher_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQStringMatcherFromPointer(ptr unsafe.Pointer) *QStringMatcher {
|
|
var n = new(QStringMatcher)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQStringMatcherFromPointer(ptr unsafe.Pointer) *QStringMatcher {
|
|
var n = NewQStringMatcherFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQStringMatcher3(uc QChar_ITF, length int, cs Qt__CaseSensitivity) *QStringMatcher {
|
|
defer qt.Recovering("QStringMatcher::QStringMatcher")
|
|
|
|
return newQStringMatcherFromPointer(C.QStringMatcher_NewQStringMatcher3(PointerFromQChar(uc), C.int(length), C.int(cs)))
|
|
}
|
|
|
|
func (ptr *QStringMatcher) Pattern() string {
|
|
defer qt.Recovering("QStringMatcher::pattern")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStringMatcher_Pattern(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func NewQStringMatcher() *QStringMatcher {
|
|
defer qt.Recovering("QStringMatcher::QStringMatcher")
|
|
|
|
return newQStringMatcherFromPointer(C.QStringMatcher_NewQStringMatcher())
|
|
}
|
|
|
|
func NewQStringMatcher2(pattern string, cs Qt__CaseSensitivity) *QStringMatcher {
|
|
defer qt.Recovering("QStringMatcher::QStringMatcher")
|
|
|
|
return newQStringMatcherFromPointer(C.QStringMatcher_NewQStringMatcher2(C.CString(pattern), C.int(cs)))
|
|
}
|
|
|
|
func NewQStringMatcher4(other QStringMatcher_ITF) *QStringMatcher {
|
|
defer qt.Recovering("QStringMatcher::QStringMatcher")
|
|
|
|
return newQStringMatcherFromPointer(C.QStringMatcher_NewQStringMatcher4(PointerFromQStringMatcher(other)))
|
|
}
|
|
|
|
func (ptr *QStringMatcher) CaseSensitivity() Qt__CaseSensitivity {
|
|
defer qt.Recovering("QStringMatcher::caseSensitivity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__CaseSensitivity(C.QStringMatcher_CaseSensitivity(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringMatcher) IndexIn2(str QChar_ITF, length int, from int) int {
|
|
defer qt.Recovering("QStringMatcher::indexIn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringMatcher_IndexIn2(ptr.Pointer(), PointerFromQChar(str), C.int(length), C.int(from)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringMatcher) IndexIn(str string, from int) int {
|
|
defer qt.Recovering("QStringMatcher::indexIn")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringMatcher_IndexIn(ptr.Pointer(), C.CString(str), C.int(from)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringMatcher) SetCaseSensitivity(cs Qt__CaseSensitivity) {
|
|
defer qt.Recovering("QStringMatcher::setCaseSensitivity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringMatcher_SetCaseSensitivity(ptr.Pointer(), C.int(cs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringMatcher) SetPattern(pattern string) {
|
|
defer qt.Recovering("QStringMatcher::setPattern")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringMatcher_SetPattern(ptr.Pointer(), C.CString(pattern))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringMatcher) DestroyQStringMatcher() {
|
|
defer qt.Recovering("QStringMatcher::~QStringMatcher")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringMatcher_DestroyQStringMatcher(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QStringRef struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QStringRef_ITF interface {
|
|
QStringRef_PTR() *QStringRef
|
|
}
|
|
|
|
func (p *QStringRef) QStringRef_PTR() *QStringRef {
|
|
return p
|
|
}
|
|
|
|
func (p *QStringRef) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QStringRef) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQStringRef(ptr QStringRef_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QStringRef_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQStringRefFromPointer(ptr unsafe.Pointer) *QStringRef {
|
|
var n = new(QStringRef)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQStringRefFromPointer(ptr unsafe.Pointer) *QStringRef {
|
|
var n = NewQStringRefFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QStringRef) Left(n int) *QStringRef {
|
|
defer qt.Recovering("QStringRef::left")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QStringRef_Left(ptr.Pointer(), C.int(n)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringRef) Mid(position int, n int) *QStringRef {
|
|
defer qt.Recovering("QStringRef::mid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QStringRef_Mid(ptr.Pointer(), C.int(position), C.int(n)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringRef) Right(n int) *QStringRef {
|
|
defer qt.Recovering("QStringRef::right")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QStringRef_Right(ptr.Pointer(), C.int(n)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringRef) ToLong(ok bool, base int) int {
|
|
defer qt.Recovering("QStringRef::toLong")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_ToLong(ptr.Pointer(), C.int(qt.GoBoolToInt(ok)), C.int(base)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func NewQStringRef() *QStringRef {
|
|
defer qt.Recovering("QStringRef::QStringRef")
|
|
|
|
return newQStringRefFromPointer(C.QStringRef_NewQStringRef())
|
|
}
|
|
|
|
func NewQStringRef5(other QStringRef_ITF) *QStringRef {
|
|
defer qt.Recovering("QStringRef::QStringRef")
|
|
|
|
return newQStringRefFromPointer(C.QStringRef_NewQStringRef5(PointerFromQStringRef(other)))
|
|
}
|
|
|
|
func NewQStringRef3(stri string) *QStringRef {
|
|
defer qt.Recovering("QStringRef::QStringRef")
|
|
|
|
return newQStringRefFromPointer(C.QStringRef_NewQStringRef3(C.CString(stri)))
|
|
}
|
|
|
|
func NewQStringRef2(stri string, position int, length int) *QStringRef {
|
|
defer qt.Recovering("QStringRef::QStringRef")
|
|
|
|
return newQStringRefFromPointer(C.QStringRef_NewQStringRef2(C.CString(stri), C.int(position), C.int(length)))
|
|
}
|
|
|
|
func NewQStringRef4(other QStringRef_ITF) *QStringRef {
|
|
defer qt.Recovering("QStringRef::QStringRef")
|
|
|
|
return newQStringRefFromPointer(C.QStringRef_NewQStringRef4(PointerFromQStringRef(other)))
|
|
}
|
|
|
|
func (ptr *QStringRef) AppendTo(stri string) *QStringRef {
|
|
defer qt.Recovering("QStringRef::appendTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QStringRef_AppendTo(ptr.Pointer(), C.CString(stri)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringRef) Begin() *QChar {
|
|
defer qt.Recovering("QStringRef::begin")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQCharFromPointer(C.QStringRef_Begin(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringRef) Cbegin() *QChar {
|
|
defer qt.Recovering("QStringRef::cbegin")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQCharFromPointer(C.QStringRef_Cbegin(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringRef) Cend() *QChar {
|
|
defer qt.Recovering("QStringRef::cend")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQCharFromPointer(C.QStringRef_Cend(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringRef) Clear() {
|
|
defer qt.Recovering("QStringRef::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringRef_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func QStringRef_Compare6(s1 QStringRef_ITF, s2 QLatin1String_ITF, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::compare")
|
|
|
|
return int(C.QStringRef_QStringRef_Compare6(PointerFromQStringRef(s1), PointerFromQLatin1String(s2), C.int(cs)))
|
|
}
|
|
|
|
func (ptr *QStringRef) Compare6(s1 QStringRef_ITF, s2 QLatin1String_ITF, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::compare")
|
|
|
|
return int(C.QStringRef_QStringRef_Compare6(PointerFromQStringRef(s1), PointerFromQLatin1String(s2), C.int(cs)))
|
|
}
|
|
|
|
func QStringRef_Compare(s1 QStringRef_ITF, s2 string, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::compare")
|
|
|
|
return int(C.QStringRef_QStringRef_Compare(PointerFromQStringRef(s1), C.CString(s2), C.int(cs)))
|
|
}
|
|
|
|
func (ptr *QStringRef) Compare(s1 QStringRef_ITF, s2 string, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::compare")
|
|
|
|
return int(C.QStringRef_QStringRef_Compare(PointerFromQStringRef(s1), C.CString(s2), C.int(cs)))
|
|
}
|
|
|
|
func QStringRef_Compare5(s1 QStringRef_ITF, s2 QStringRef_ITF, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::compare")
|
|
|
|
return int(C.QStringRef_QStringRef_Compare5(PointerFromQStringRef(s1), PointerFromQStringRef(s2), C.int(cs)))
|
|
}
|
|
|
|
func (ptr *QStringRef) Compare5(s1 QStringRef_ITF, s2 QStringRef_ITF, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::compare")
|
|
|
|
return int(C.QStringRef_QStringRef_Compare5(PointerFromQStringRef(s1), PointerFromQStringRef(s2), C.int(cs)))
|
|
}
|
|
|
|
func (ptr *QStringRef) Compare3(other QLatin1String_ITF, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::compare")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_Compare3(ptr.Pointer(), PointerFromQLatin1String(other), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) Compare4(other string, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::compare")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_Compare4(ptr.Pointer(), C.CString(other), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) Compare2(other QStringRef_ITF, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::compare")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_Compare2(ptr.Pointer(), PointerFromQStringRef(other), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) ConstData() *QChar {
|
|
defer qt.Recovering("QStringRef::constData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQCharFromPointer(C.QStringRef_ConstData(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringRef) Contains2(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
|
|
defer qt.Recovering("QStringRef::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_Contains2(ptr.Pointer(), PointerFromQChar(ch), C.int(cs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) Contains3(str QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
|
|
defer qt.Recovering("QStringRef::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_Contains3(ptr.Pointer(), PointerFromQLatin1String(str), C.int(cs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) Contains(str string, cs Qt__CaseSensitivity) bool {
|
|
defer qt.Recovering("QStringRef::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_Contains(ptr.Pointer(), C.CString(str), C.int(cs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) Contains4(str QStringRef_ITF, cs Qt__CaseSensitivity) bool {
|
|
defer qt.Recovering("QStringRef::contains")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_Contains4(ptr.Pointer(), PointerFromQStringRef(str), C.int(cs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) Count() int {
|
|
defer qt.Recovering("QStringRef::count")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_Count(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) Count3(ch QChar_ITF, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::count")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_Count3(ptr.Pointer(), PointerFromQChar(ch), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) Count2(str string, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::count")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_Count2(ptr.Pointer(), C.CString(str), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) Count4(str QStringRef_ITF, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::count")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_Count4(ptr.Pointer(), PointerFromQStringRef(str), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) Data() *QChar {
|
|
defer qt.Recovering("QStringRef::data")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQCharFromPointer(C.QStringRef_Data(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringRef) End() *QChar {
|
|
defer qt.Recovering("QStringRef::end")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQCharFromPointer(C.QStringRef_End(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringRef) EndsWith3(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
|
|
defer qt.Recovering("QStringRef::endsWith")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_EndsWith3(ptr.Pointer(), PointerFromQChar(ch), C.int(cs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) EndsWith2(str QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
|
|
defer qt.Recovering("QStringRef::endsWith")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_EndsWith2(ptr.Pointer(), PointerFromQLatin1String(str), C.int(cs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) EndsWith(str string, cs Qt__CaseSensitivity) bool {
|
|
defer qt.Recovering("QStringRef::endsWith")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_EndsWith(ptr.Pointer(), C.CString(str), C.int(cs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) EndsWith4(str QStringRef_ITF, cs Qt__CaseSensitivity) bool {
|
|
defer qt.Recovering("QStringRef::endsWith")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_EndsWith4(ptr.Pointer(), PointerFromQStringRef(str), C.int(cs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) IndexOf2(ch QChar_ITF, from int, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::indexOf")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_IndexOf2(ptr.Pointer(), PointerFromQChar(ch), C.int(from), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) IndexOf3(str QLatin1String_ITF, from int, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::indexOf")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_IndexOf3(ptr.Pointer(), PointerFromQLatin1String(str), C.int(from), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) IndexOf(str string, from int, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::indexOf")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_IndexOf(ptr.Pointer(), C.CString(str), C.int(from), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) IndexOf4(str QStringRef_ITF, from int, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::indexOf")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_IndexOf4(ptr.Pointer(), PointerFromQStringRef(str), C.int(from), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) IsEmpty() bool {
|
|
defer qt.Recovering("QStringRef::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) IsNull() bool {
|
|
defer qt.Recovering("QStringRef::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) LastIndexOf2(ch QChar_ITF, from int, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::lastIndexOf")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_LastIndexOf2(ptr.Pointer(), PointerFromQChar(ch), C.int(from), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) LastIndexOf3(str QLatin1String_ITF, from int, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::lastIndexOf")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_LastIndexOf3(ptr.Pointer(), PointerFromQLatin1String(str), C.int(from), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) LastIndexOf(str string, from int, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::lastIndexOf")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_LastIndexOf(ptr.Pointer(), C.CString(str), C.int(from), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) LastIndexOf4(str QStringRef_ITF, from int, cs Qt__CaseSensitivity) int {
|
|
defer qt.Recovering("QStringRef::lastIndexOf")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_LastIndexOf4(ptr.Pointer(), PointerFromQStringRef(str), C.int(from), C.int(cs)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) Length() int {
|
|
defer qt.Recovering("QStringRef::length")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_Length(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func QStringRef_LocaleAwareCompare(s1 QStringRef_ITF, s2 string) int {
|
|
defer qt.Recovering("QStringRef::localeAwareCompare")
|
|
|
|
return int(C.QStringRef_QStringRef_LocaleAwareCompare(PointerFromQStringRef(s1), C.CString(s2)))
|
|
}
|
|
|
|
func (ptr *QStringRef) LocaleAwareCompare(s1 QStringRef_ITF, s2 string) int {
|
|
defer qt.Recovering("QStringRef::localeAwareCompare")
|
|
|
|
return int(C.QStringRef_QStringRef_LocaleAwareCompare(PointerFromQStringRef(s1), C.CString(s2)))
|
|
}
|
|
|
|
func QStringRef_LocaleAwareCompare4(s1 QStringRef_ITF, s2 QStringRef_ITF) int {
|
|
defer qt.Recovering("QStringRef::localeAwareCompare")
|
|
|
|
return int(C.QStringRef_QStringRef_LocaleAwareCompare4(PointerFromQStringRef(s1), PointerFromQStringRef(s2)))
|
|
}
|
|
|
|
func (ptr *QStringRef) LocaleAwareCompare4(s1 QStringRef_ITF, s2 QStringRef_ITF) int {
|
|
defer qt.Recovering("QStringRef::localeAwareCompare")
|
|
|
|
return int(C.QStringRef_QStringRef_LocaleAwareCompare4(PointerFromQStringRef(s1), PointerFromQStringRef(s2)))
|
|
}
|
|
|
|
func (ptr *QStringRef) LocaleAwareCompare3(other string) int {
|
|
defer qt.Recovering("QStringRef::localeAwareCompare")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_LocaleAwareCompare3(ptr.Pointer(), C.CString(other)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) LocaleAwareCompare2(other QStringRef_ITF) int {
|
|
defer qt.Recovering("QStringRef::localeAwareCompare")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_LocaleAwareCompare2(ptr.Pointer(), PointerFromQStringRef(other)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) Position() int {
|
|
defer qt.Recovering("QStringRef::position")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_Position(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) Size() int {
|
|
defer qt.Recovering("QStringRef::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) StartsWith3(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
|
|
defer qt.Recovering("QStringRef::startsWith")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_StartsWith3(ptr.Pointer(), PointerFromQChar(ch), C.int(cs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) StartsWith2(str QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
|
|
defer qt.Recovering("QStringRef::startsWith")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_StartsWith2(ptr.Pointer(), PointerFromQLatin1String(str), C.int(cs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) StartsWith(str string, cs Qt__CaseSensitivity) bool {
|
|
defer qt.Recovering("QStringRef::startsWith")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_StartsWith(ptr.Pointer(), C.CString(str), C.int(cs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) StartsWith4(str QStringRef_ITF, cs Qt__CaseSensitivity) bool {
|
|
defer qt.Recovering("QStringRef::startsWith")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QStringRef_StartsWith4(ptr.Pointer(), PointerFromQStringRef(str), C.int(cs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QStringRef) String() string {
|
|
defer qt.Recovering("QStringRef::string")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStringRef_String(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QStringRef) ToInt(ok bool, base int) int {
|
|
defer qt.Recovering("QStringRef::toInt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QStringRef_ToInt(ptr.Pointer(), C.int(qt.GoBoolToInt(ok)), C.int(base)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QStringRef) ToLatin1() string {
|
|
defer qt.Recovering("QStringRef::toLatin1")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStringRef_ToLatin1(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QStringRef) ToLocal8Bit() string {
|
|
defer qt.Recovering("QStringRef::toLocal8Bit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStringRef_ToLocal8Bit(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QStringRef) ToString() string {
|
|
defer qt.Recovering("QStringRef::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStringRef_ToString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QStringRef) ToUtf8() string {
|
|
defer qt.Recovering("QStringRef::toUtf8")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QStringRef_ToUtf8(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QStringRef) Trimmed() *QStringRef {
|
|
defer qt.Recovering("QStringRef::trimmed")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QStringRef_Trimmed(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringRef) Truncate(position int) {
|
|
defer qt.Recovering("QStringRef::truncate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringRef_Truncate(ptr.Pointer(), C.int(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QStringRef) Unicode() *QChar {
|
|
defer qt.Recovering("QStringRef::unicode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQCharFromPointer(C.QStringRef_Unicode(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QStringRef) DestroyQStringRef() {
|
|
defer qt.Recovering("QStringRef::~QStringRef")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QStringRef_DestroyQStringRef(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QSysInfo::Endian
|
|
type QSysInfo__Endian int64
|
|
|
|
const (
|
|
QSysInfo__BigEndian = QSysInfo__Endian(0)
|
|
QSysInfo__LittleEndian = QSysInfo__Endian(1)
|
|
)
|
|
|
|
//QSysInfo::MacVersion
|
|
type QSysInfo__MacVersion int64
|
|
|
|
var (
|
|
QSysInfo__MV_None = QSysInfo__MacVersion(0xffff)
|
|
QSysInfo__MV_Unknown = QSysInfo__MacVersion(0x0000)
|
|
QSysInfo__MV_9 = QSysInfo__MacVersion(C.QSysInfo_MV_9_Type())
|
|
QSysInfo__MV_10_0 = QSysInfo__MacVersion(C.QSysInfo_MV_10_0_Type())
|
|
QSysInfo__MV_10_1 = QSysInfo__MacVersion(C.QSysInfo_MV_10_1_Type())
|
|
QSysInfo__MV_10_2 = QSysInfo__MacVersion(C.QSysInfo_MV_10_2_Type())
|
|
QSysInfo__MV_10_3 = QSysInfo__MacVersion(C.QSysInfo_MV_10_3_Type())
|
|
QSysInfo__MV_10_4 = QSysInfo__MacVersion(C.QSysInfo_MV_10_4_Type())
|
|
QSysInfo__MV_10_5 = QSysInfo__MacVersion(C.QSysInfo_MV_10_5_Type())
|
|
QSysInfo__MV_10_6 = QSysInfo__MacVersion(C.QSysInfo_MV_10_6_Type())
|
|
QSysInfo__MV_10_7 = QSysInfo__MacVersion(C.QSysInfo_MV_10_7_Type())
|
|
QSysInfo__MV_10_8 = QSysInfo__MacVersion(C.QSysInfo_MV_10_8_Type())
|
|
QSysInfo__MV_10_9 = QSysInfo__MacVersion(C.QSysInfo_MV_10_9_Type())
|
|
QSysInfo__MV_10_10 = QSysInfo__MacVersion(C.QSysInfo_MV_10_10_Type())
|
|
QSysInfo__MV_10_11 = QSysInfo__MacVersion(C.QSysInfo_MV_10_11_Type())
|
|
QSysInfo__MV_CHEETAH = QSysInfo__MacVersion(QSysInfo__MV_10_0)
|
|
QSysInfo__MV_PUMA = QSysInfo__MacVersion(QSysInfo__MV_10_1)
|
|
QSysInfo__MV_JAGUAR = QSysInfo__MacVersion(QSysInfo__MV_10_2)
|
|
QSysInfo__MV_PANTHER = QSysInfo__MacVersion(QSysInfo__MV_10_3)
|
|
QSysInfo__MV_TIGER = QSysInfo__MacVersion(QSysInfo__MV_10_4)
|
|
QSysInfo__MV_LEOPARD = QSysInfo__MacVersion(QSysInfo__MV_10_5)
|
|
QSysInfo__MV_SNOWLEOPARD = QSysInfo__MacVersion(QSysInfo__MV_10_6)
|
|
QSysInfo__MV_LION = QSysInfo__MacVersion(QSysInfo__MV_10_7)
|
|
QSysInfo__MV_MOUNTAINLION = QSysInfo__MacVersion(QSysInfo__MV_10_8)
|
|
QSysInfo__MV_MAVERICKS = QSysInfo__MacVersion(QSysInfo__MV_10_9)
|
|
QSysInfo__MV_YOSEMITE = QSysInfo__MacVersion(QSysInfo__MV_10_10)
|
|
QSysInfo__MV_ELCAPITAN = QSysInfo__MacVersion(QSysInfo__MV_10_11)
|
|
QSysInfo__MV_IOS = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_Type())
|
|
QSysInfo__MV_IOS_4_3 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_4_3_Type())
|
|
QSysInfo__MV_IOS_5_0 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_5_0_Type())
|
|
QSysInfo__MV_IOS_5_1 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_5_1_Type())
|
|
QSysInfo__MV_IOS_6_0 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_6_0_Type())
|
|
QSysInfo__MV_IOS_6_1 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_6_1_Type())
|
|
QSysInfo__MV_IOS_7_0 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_7_0_Type())
|
|
QSysInfo__MV_IOS_7_1 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_7_1_Type())
|
|
QSysInfo__MV_IOS_8_0 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_8_0_Type())
|
|
QSysInfo__MV_IOS_8_1 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_8_1_Type())
|
|
QSysInfo__MV_IOS_8_2 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_8_2_Type())
|
|
QSysInfo__MV_IOS_8_3 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_8_3_Type())
|
|
QSysInfo__MV_IOS_8_4 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_8_4_Type())
|
|
QSysInfo__MV_IOS_9_0 = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_9_0_Type())
|
|
)
|
|
|
|
//QSysInfo::Sizes
|
|
type QSysInfo__Sizes int64
|
|
|
|
var (
|
|
QSysInfo__WordSize = QSysInfo__Sizes(C.QSysInfo_WordSize_Type())
|
|
)
|
|
|
|
//QSysInfo::WinVersion
|
|
type QSysInfo__WinVersion int64
|
|
|
|
const (
|
|
QSysInfo__WV_None = QSysInfo__WinVersion(0x0000)
|
|
QSysInfo__WV_32s = QSysInfo__WinVersion(0x0001)
|
|
QSysInfo__WV_95 = QSysInfo__WinVersion(0x0002)
|
|
QSysInfo__WV_98 = QSysInfo__WinVersion(0x0003)
|
|
QSysInfo__WV_Me = QSysInfo__WinVersion(0x0004)
|
|
QSysInfo__WV_DOS_based = QSysInfo__WinVersion(0x000f)
|
|
QSysInfo__WV_NT = QSysInfo__WinVersion(0x0010)
|
|
QSysInfo__WV_2000 = QSysInfo__WinVersion(0x0020)
|
|
QSysInfo__WV_XP = QSysInfo__WinVersion(0x0030)
|
|
QSysInfo__WV_2003 = QSysInfo__WinVersion(0x0040)
|
|
QSysInfo__WV_VISTA = QSysInfo__WinVersion(0x0080)
|
|
QSysInfo__WV_WINDOWS7 = QSysInfo__WinVersion(0x0090)
|
|
QSysInfo__WV_WINDOWS8 = QSysInfo__WinVersion(0x00a0)
|
|
QSysInfo__WV_WINDOWS8_1 = QSysInfo__WinVersion(0x00b0)
|
|
QSysInfo__WV_WINDOWS10 = QSysInfo__WinVersion(0x00c0)
|
|
QSysInfo__WV_NT_based = QSysInfo__WinVersion(0x00f0)
|
|
QSysInfo__WV_4_0 = QSysInfo__WinVersion(QSysInfo__WV_NT)
|
|
QSysInfo__WV_5_0 = QSysInfo__WinVersion(QSysInfo__WV_2000)
|
|
QSysInfo__WV_5_1 = QSysInfo__WinVersion(QSysInfo__WV_XP)
|
|
QSysInfo__WV_5_2 = QSysInfo__WinVersion(QSysInfo__WV_2003)
|
|
QSysInfo__WV_6_0 = QSysInfo__WinVersion(QSysInfo__WV_VISTA)
|
|
QSysInfo__WV_6_1 = QSysInfo__WinVersion(QSysInfo__WV_WINDOWS7)
|
|
QSysInfo__WV_6_2 = QSysInfo__WinVersion(QSysInfo__WV_WINDOWS8)
|
|
QSysInfo__WV_6_3 = QSysInfo__WinVersion(QSysInfo__WV_WINDOWS8_1)
|
|
QSysInfo__WV_10_0 = QSysInfo__WinVersion(QSysInfo__WV_WINDOWS10)
|
|
QSysInfo__WV_CE = QSysInfo__WinVersion(0x0100)
|
|
QSysInfo__WV_CENET = QSysInfo__WinVersion(0x0200)
|
|
QSysInfo__WV_CE_5 = QSysInfo__WinVersion(0x0300)
|
|
QSysInfo__WV_CE_6 = QSysInfo__WinVersion(0x0400)
|
|
QSysInfo__WV_CE_based = QSysInfo__WinVersion(0x0f00)
|
|
)
|
|
|
|
type QSysInfo struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSysInfo_ITF interface {
|
|
QSysInfo_PTR() *QSysInfo
|
|
}
|
|
|
|
func (p *QSysInfo) QSysInfo_PTR() *QSysInfo {
|
|
return p
|
|
}
|
|
|
|
func (p *QSysInfo) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSysInfo) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQSysInfo(ptr QSysInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSysInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSysInfoFromPointer(ptr unsafe.Pointer) *QSysInfo {
|
|
var n = new(QSysInfo)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSysInfoFromPointer(ptr unsafe.Pointer) *QSysInfo {
|
|
var n = NewQSysInfoFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func QSysInfo_MacVersion() QSysInfo__MacVersion {
|
|
defer qt.Recovering("QSysInfo::macVersion")
|
|
|
|
return QSysInfo__MacVersion(C.QSysInfo_QSysInfo_MacVersion())
|
|
}
|
|
|
|
func (ptr *QSysInfo) MacVersion() QSysInfo__MacVersion {
|
|
defer qt.Recovering("QSysInfo::macVersion")
|
|
|
|
return QSysInfo__MacVersion(C.QSysInfo_QSysInfo_MacVersion())
|
|
}
|
|
|
|
func QSysInfo_BuildAbi() string {
|
|
defer qt.Recovering("QSysInfo::buildAbi")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_BuildAbi())
|
|
}
|
|
|
|
func (ptr *QSysInfo) BuildAbi() string {
|
|
defer qt.Recovering("QSysInfo::buildAbi")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_BuildAbi())
|
|
}
|
|
|
|
func QSysInfo_BuildCpuArchitecture() string {
|
|
defer qt.Recovering("QSysInfo::buildCpuArchitecture")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_BuildCpuArchitecture())
|
|
}
|
|
|
|
func (ptr *QSysInfo) BuildCpuArchitecture() string {
|
|
defer qt.Recovering("QSysInfo::buildCpuArchitecture")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_BuildCpuArchitecture())
|
|
}
|
|
|
|
func QSysInfo_CurrentCpuArchitecture() string {
|
|
defer qt.Recovering("QSysInfo::currentCpuArchitecture")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_CurrentCpuArchitecture())
|
|
}
|
|
|
|
func (ptr *QSysInfo) CurrentCpuArchitecture() string {
|
|
defer qt.Recovering("QSysInfo::currentCpuArchitecture")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_CurrentCpuArchitecture())
|
|
}
|
|
|
|
func QSysInfo_KernelType() string {
|
|
defer qt.Recovering("QSysInfo::kernelType")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_KernelType())
|
|
}
|
|
|
|
func (ptr *QSysInfo) KernelType() string {
|
|
defer qt.Recovering("QSysInfo::kernelType")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_KernelType())
|
|
}
|
|
|
|
func QSysInfo_KernelVersion() string {
|
|
defer qt.Recovering("QSysInfo::kernelVersion")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_KernelVersion())
|
|
}
|
|
|
|
func (ptr *QSysInfo) KernelVersion() string {
|
|
defer qt.Recovering("QSysInfo::kernelVersion")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_KernelVersion())
|
|
}
|
|
|
|
func QSysInfo_MachineHostName() string {
|
|
defer qt.Recovering("QSysInfo::machineHostName")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_MachineHostName())
|
|
}
|
|
|
|
func (ptr *QSysInfo) MachineHostName() string {
|
|
defer qt.Recovering("QSysInfo::machineHostName")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_MachineHostName())
|
|
}
|
|
|
|
func QSysInfo_PrettyProductName() string {
|
|
defer qt.Recovering("QSysInfo::prettyProductName")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_PrettyProductName())
|
|
}
|
|
|
|
func (ptr *QSysInfo) PrettyProductName() string {
|
|
defer qt.Recovering("QSysInfo::prettyProductName")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_PrettyProductName())
|
|
}
|
|
|
|
func QSysInfo_ProductType() string {
|
|
defer qt.Recovering("QSysInfo::productType")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_ProductType())
|
|
}
|
|
|
|
func (ptr *QSysInfo) ProductType() string {
|
|
defer qt.Recovering("QSysInfo::productType")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_ProductType())
|
|
}
|
|
|
|
func QSysInfo_ProductVersion() string {
|
|
defer qt.Recovering("QSysInfo::productVersion")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_ProductVersion())
|
|
}
|
|
|
|
func (ptr *QSysInfo) ProductVersion() string {
|
|
defer qt.Recovering("QSysInfo::productVersion")
|
|
|
|
return C.GoString(C.QSysInfo_QSysInfo_ProductVersion())
|
|
}
|
|
|
|
func QSysInfo_WindowsVersion() QSysInfo__WinVersion {
|
|
defer qt.Recovering("QSysInfo::windowsVersion")
|
|
|
|
return QSysInfo__WinVersion(C.QSysInfo_QSysInfo_WindowsVersion())
|
|
}
|
|
|
|
func (ptr *QSysInfo) WindowsVersion() QSysInfo__WinVersion {
|
|
defer qt.Recovering("QSysInfo::windowsVersion")
|
|
|
|
return QSysInfo__WinVersion(C.QSysInfo_QSysInfo_WindowsVersion())
|
|
}
|
|
|
|
func QSysInfo_MacintoshVersion() QSysInfo__MacVersion {
|
|
defer qt.Recovering("QSysInfo::MacintoshVersion")
|
|
|
|
return QSysInfo__MacVersion(C.QSysInfo_QSysInfo_MacintoshVersion())
|
|
}
|
|
|
|
func (ptr *QSysInfo) MacintoshVersion() QSysInfo__MacVersion {
|
|
defer qt.Recovering("QSysInfo::MacintoshVersion")
|
|
|
|
return QSysInfo__MacVersion(C.QSysInfo_QSysInfo_MacintoshVersion())
|
|
}
|
|
|
|
//QSystemSemaphore::AccessMode
|
|
type QSystemSemaphore__AccessMode int64
|
|
|
|
const (
|
|
QSystemSemaphore__Open = QSystemSemaphore__AccessMode(0)
|
|
QSystemSemaphore__Create = QSystemSemaphore__AccessMode(1)
|
|
)
|
|
|
|
//QSystemSemaphore::SystemSemaphoreError
|
|
type QSystemSemaphore__SystemSemaphoreError int64
|
|
|
|
const (
|
|
QSystemSemaphore__NoError = QSystemSemaphore__SystemSemaphoreError(0)
|
|
QSystemSemaphore__PermissionDenied = QSystemSemaphore__SystemSemaphoreError(1)
|
|
QSystemSemaphore__KeyError = QSystemSemaphore__SystemSemaphoreError(2)
|
|
QSystemSemaphore__AlreadyExists = QSystemSemaphore__SystemSemaphoreError(3)
|
|
QSystemSemaphore__NotFound = QSystemSemaphore__SystemSemaphoreError(4)
|
|
QSystemSemaphore__OutOfResources = QSystemSemaphore__SystemSemaphoreError(5)
|
|
QSystemSemaphore__UnknownError = QSystemSemaphore__SystemSemaphoreError(6)
|
|
)
|
|
|
|
type QSystemSemaphore struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSystemSemaphore_ITF interface {
|
|
QSystemSemaphore_PTR() *QSystemSemaphore
|
|
}
|
|
|
|
func (p *QSystemSemaphore) QSystemSemaphore_PTR() *QSystemSemaphore {
|
|
return p
|
|
}
|
|
|
|
func (p *QSystemSemaphore) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QSystemSemaphore) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQSystemSemaphore(ptr QSystemSemaphore_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSystemSemaphore_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSystemSemaphoreFromPointer(ptr unsafe.Pointer) *QSystemSemaphore {
|
|
var n = new(QSystemSemaphore)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQSystemSemaphoreFromPointer(ptr unsafe.Pointer) *QSystemSemaphore {
|
|
var n = NewQSystemSemaphoreFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQSystemSemaphore(key string, initialValue int, mode QSystemSemaphore__AccessMode) *QSystemSemaphore {
|
|
defer qt.Recovering("QSystemSemaphore::QSystemSemaphore")
|
|
|
|
return newQSystemSemaphoreFromPointer(C.QSystemSemaphore_NewQSystemSemaphore(C.CString(key), C.int(initialValue), C.int(mode)))
|
|
}
|
|
|
|
func (ptr *QSystemSemaphore) Acquire() bool {
|
|
defer qt.Recovering("QSystemSemaphore::acquire")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSystemSemaphore_Acquire(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSystemSemaphore) Error() QSystemSemaphore__SystemSemaphoreError {
|
|
defer qt.Recovering("QSystemSemaphore::error")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QSystemSemaphore__SystemSemaphoreError(C.QSystemSemaphore_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSystemSemaphore) ErrorString() string {
|
|
defer qt.Recovering("QSystemSemaphore::errorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QSystemSemaphore_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QSystemSemaphore) Key() string {
|
|
defer qt.Recovering("QSystemSemaphore::key")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QSystemSemaphore_Key(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QSystemSemaphore) Release(n int) bool {
|
|
defer qt.Recovering("QSystemSemaphore::release")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QSystemSemaphore_Release(ptr.Pointer(), C.int(n)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSystemSemaphore) SetKey(key string, initialValue int, mode QSystemSemaphore__AccessMode) {
|
|
defer qt.Recovering("QSystemSemaphore::setKey")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSystemSemaphore_SetKey(ptr.Pointer(), C.CString(key), C.int(initialValue), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSystemSemaphore) DestroyQSystemSemaphore() {
|
|
defer qt.Recovering("QSystemSemaphore::~QSystemSemaphore")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QSystemSemaphore_DestroyQSystemSemaphore(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QTemporaryDir struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QTemporaryDir_ITF interface {
|
|
QTemporaryDir_PTR() *QTemporaryDir
|
|
}
|
|
|
|
func (p *QTemporaryDir) QTemporaryDir_PTR() *QTemporaryDir {
|
|
return p
|
|
}
|
|
|
|
func (p *QTemporaryDir) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTemporaryDir) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQTemporaryDir(ptr QTemporaryDir_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTemporaryDir_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTemporaryDirFromPointer(ptr unsafe.Pointer) *QTemporaryDir {
|
|
var n = new(QTemporaryDir)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTemporaryDirFromPointer(ptr unsafe.Pointer) *QTemporaryDir {
|
|
var n = NewQTemporaryDirFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQTemporaryDir() *QTemporaryDir {
|
|
defer qt.Recovering("QTemporaryDir::QTemporaryDir")
|
|
|
|
return newQTemporaryDirFromPointer(C.QTemporaryDir_NewQTemporaryDir())
|
|
}
|
|
|
|
func NewQTemporaryDir2(templatePath string) *QTemporaryDir {
|
|
defer qt.Recovering("QTemporaryDir::QTemporaryDir")
|
|
|
|
return newQTemporaryDirFromPointer(C.QTemporaryDir_NewQTemporaryDir2(C.CString(templatePath)))
|
|
}
|
|
|
|
func (ptr *QTemporaryDir) AutoRemove() bool {
|
|
defer qt.Recovering("QTemporaryDir::autoRemove")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryDir_AutoRemove(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryDir) ErrorString() string {
|
|
defer qt.Recovering("QTemporaryDir::errorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTemporaryDir_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTemporaryDir) IsValid() bool {
|
|
defer qt.Recovering("QTemporaryDir::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryDir_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryDir) Path() string {
|
|
defer qt.Recovering("QTemporaryDir::path")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTemporaryDir_Path(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTemporaryDir) Remove() bool {
|
|
defer qt.Recovering("QTemporaryDir::remove")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryDir_Remove(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryDir) SetAutoRemove(b bool) {
|
|
defer qt.Recovering("QTemporaryDir::setAutoRemove")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryDir_SetAutoRemove(ptr.Pointer(), C.int(qt.GoBoolToInt(b)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryDir) DestroyQTemporaryDir() {
|
|
defer qt.Recovering("QTemporaryDir::~QTemporaryDir")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryDir_DestroyQTemporaryDir(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QTemporaryFile struct {
|
|
QFile
|
|
}
|
|
|
|
type QTemporaryFile_ITF interface {
|
|
QFile_ITF
|
|
QTemporaryFile_PTR() *QTemporaryFile
|
|
}
|
|
|
|
func (p *QTemporaryFile) QTemporaryFile_PTR() *QTemporaryFile {
|
|
return p
|
|
}
|
|
|
|
func (p *QTemporaryFile) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QFile_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTemporaryFile) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QFile_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQTemporaryFile(ptr QTemporaryFile_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTemporaryFile_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTemporaryFileFromPointer(ptr unsafe.Pointer) *QTemporaryFile {
|
|
var n = new(QTemporaryFile)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTemporaryFileFromPointer(ptr unsafe.Pointer) *QTemporaryFile {
|
|
var n = NewQTemporaryFileFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QTemporaryFile_") {
|
|
n.SetObjectName("QTemporaryFile_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQTemporaryFile() *QTemporaryFile {
|
|
defer qt.Recovering("QTemporaryFile::QTemporaryFile")
|
|
|
|
return newQTemporaryFileFromPointer(C.QTemporaryFile_NewQTemporaryFile())
|
|
}
|
|
|
|
func NewQTemporaryFile3(parent QObject_ITF) *QTemporaryFile {
|
|
defer qt.Recovering("QTemporaryFile::QTemporaryFile")
|
|
|
|
return newQTemporaryFileFromPointer(C.QTemporaryFile_NewQTemporaryFile3(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func NewQTemporaryFile2(templateName string) *QTemporaryFile {
|
|
defer qt.Recovering("QTemporaryFile::QTemporaryFile")
|
|
|
|
return newQTemporaryFileFromPointer(C.QTemporaryFile_NewQTemporaryFile2(C.CString(templateName)))
|
|
}
|
|
|
|
func NewQTemporaryFile4(templateName string, parent QObject_ITF) *QTemporaryFile {
|
|
defer qt.Recovering("QTemporaryFile::QTemporaryFile")
|
|
|
|
return newQTemporaryFileFromPointer(C.QTemporaryFile_NewQTemporaryFile4(C.CString(templateName), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) AutoRemove() bool {
|
|
defer qt.Recovering("QTemporaryFile::autoRemove")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_AutoRemove(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QTemporaryFile_CreateNativeFile(file QFile_ITF) *QTemporaryFile {
|
|
defer qt.Recovering("QTemporaryFile::createNativeFile")
|
|
|
|
return NewQTemporaryFileFromPointer(C.QTemporaryFile_QTemporaryFile_CreateNativeFile(PointerFromQFile(file)))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) CreateNativeFile(file QFile_ITF) *QTemporaryFile {
|
|
defer qt.Recovering("QTemporaryFile::createNativeFile")
|
|
|
|
return NewQTemporaryFileFromPointer(C.QTemporaryFile_QTemporaryFile_CreateNativeFile(PointerFromQFile(file)))
|
|
}
|
|
|
|
func QTemporaryFile_CreateNativeFile2(fileName string) *QTemporaryFile {
|
|
defer qt.Recovering("QTemporaryFile::createNativeFile")
|
|
|
|
return NewQTemporaryFileFromPointer(C.QTemporaryFile_QTemporaryFile_CreateNativeFile2(C.CString(fileName)))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) CreateNativeFile2(fileName string) *QTemporaryFile {
|
|
defer qt.Recovering("QTemporaryFile::createNativeFile")
|
|
|
|
return NewQTemporaryFileFromPointer(C.QTemporaryFile_QTemporaryFile_CreateNativeFile2(C.CString(fileName)))
|
|
}
|
|
|
|
//export callbackQTemporaryFile_FileName
|
|
func callbackQTemporaryFile_FileName(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QTemporaryFile::fileName")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "fileName"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString(NewQTemporaryFileFromPointer(ptr).FileNameDefault())
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectFileName(f func() string) {
|
|
defer qt.Recovering("connect QTemporaryFile::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "fileName", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectFileName() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "fileName")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) FileName() string {
|
|
defer qt.Recovering("QTemporaryFile::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTemporaryFile_FileName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) FileNameDefault() string {
|
|
defer qt.Recovering("QTemporaryFile::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTemporaryFile_FileNameDefault(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) FileTemplate() string {
|
|
defer qt.Recovering("QTemporaryFile::fileTemplate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTemporaryFile_FileTemplate(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) Open() bool {
|
|
defer qt.Recovering("QTemporaryFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_Open(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTemporaryFile_Open2
|
|
func callbackQTemporaryFile_Open2(ptr unsafe.Pointer, ptrName *C.char, flags C.int) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::open")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "open2"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(QIODevice__OpenModeFlag) bool)(QIODevice__OpenModeFlag(flags))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTemporaryFileFromPointer(ptr).Open2Default(QIODevice__OpenModeFlag(flags))))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectOpen2(f func(flags QIODevice__OpenModeFlag) bool) {
|
|
defer qt.Recovering("connect QTemporaryFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "open2", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectOpen2() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "open2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) Open2(flags QIODevice__OpenModeFlag) bool {
|
|
defer qt.Recovering("QTemporaryFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_Open2(ptr.Pointer(), C.int(flags)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) Open2Default(flags QIODevice__OpenModeFlag) bool {
|
|
defer qt.Recovering("QTemporaryFile::open")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_Open2Default(ptr.Pointer(), C.int(flags)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) SetAutoRemove(b bool) {
|
|
defer qt.Recovering("QTemporaryFile::setAutoRemove")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_SetAutoRemove(ptr.Pointer(), C.int(qt.GoBoolToInt(b)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) SetFileTemplate(name string) {
|
|
defer qt.Recovering("QTemporaryFile::setFileTemplate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_SetFileTemplate(ptr.Pointer(), C.CString(name))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DestroyQTemporaryFile() {
|
|
defer qt.Recovering("QTemporaryFile::~QTemporaryFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QTemporaryFile_DestroyQTemporaryFile(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQTemporaryFile_Permissions
|
|
func callbackQTemporaryFile_Permissions(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::permissions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "permissions"); signal != nil {
|
|
return C.int(signal.(func() QFileDevice__Permission)())
|
|
}
|
|
|
|
return C.int(NewQTemporaryFileFromPointer(ptr).PermissionsDefault())
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectPermissions(f func() QFileDevice__Permission) {
|
|
defer qt.Recovering("connect QTemporaryFile::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "permissions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectPermissions() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "permissions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) Permissions() QFileDevice__Permission {
|
|
defer qt.Recovering("QTemporaryFile::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QFileDevice__Permission(C.QTemporaryFile_Permissions(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) PermissionsDefault() QFileDevice__Permission {
|
|
defer qt.Recovering("QTemporaryFile::permissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QFileDevice__Permission(C.QTemporaryFile_PermissionsDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQTemporaryFile_Resize
|
|
func callbackQTemporaryFile_Resize(ptr unsafe.Pointer, ptrName *C.char, sz C.longlong) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::resize")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resize"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int64) bool)(int64(sz))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTemporaryFileFromPointer(ptr).ResizeDefault(int64(sz))))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectResize(f func(sz int64) bool) {
|
|
defer qt.Recovering("connect QTemporaryFile::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resize", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectResize() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resize")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) Resize(sz int64) bool {
|
|
defer qt.Recovering("QTemporaryFile::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_Resize(ptr.Pointer(), C.longlong(sz)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ResizeDefault(sz int64) bool {
|
|
defer qt.Recovering("QTemporaryFile::resize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_ResizeDefault(ptr.Pointer(), C.longlong(sz)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTemporaryFile_SetPermissions
|
|
func callbackQTemporaryFile_SetPermissions(ptr unsafe.Pointer, ptrName *C.char, permissions C.int) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::setPermissions")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setPermissions"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(QFileDevice__Permission) bool)(QFileDevice__Permission(permissions))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTemporaryFileFromPointer(ptr).SetPermissionsDefault(QFileDevice__Permission(permissions))))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectSetPermissions(f func(permissions QFileDevice__Permission) bool) {
|
|
defer qt.Recovering("connect QTemporaryFile::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setPermissions", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectSetPermissions() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setPermissions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) SetPermissions(permissions QFileDevice__Permission) bool {
|
|
defer qt.Recovering("QTemporaryFile::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_SetPermissions(ptr.Pointer(), C.int(permissions)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) SetPermissionsDefault(permissions QFileDevice__Permission) bool {
|
|
defer qt.Recovering("QTemporaryFile::setPermissions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_SetPermissionsDefault(ptr.Pointer(), C.int(permissions)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTemporaryFile_Size
|
|
func callbackQTemporaryFile_Size(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QTemporaryFile::size")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "size"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQTemporaryFileFromPointer(ptr).SizeDefault())
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectSize(f func() int64) {
|
|
defer qt.Recovering("connect QTemporaryFile::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "size", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectSize() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "size")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) Size() int64 {
|
|
defer qt.Recovering("QTemporaryFile::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTemporaryFile_Size(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) SizeDefault() int64 {
|
|
defer qt.Recovering("QTemporaryFile::size")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTemporaryFile_SizeDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQTemporaryFile_Seek
|
|
func callbackQTemporaryFile_Seek(ptr unsafe.Pointer, ptrName *C.char, pos C.longlong) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::seek")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "seek"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int64) bool)(int64(pos))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTemporaryFileFromPointer(ptr).SeekDefault(int64(pos))))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectSeek(f func(pos int64) bool) {
|
|
defer qt.Recovering("connect QTemporaryFile::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "seek", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectSeek() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "seek")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) Seek(pos int64) bool {
|
|
defer qt.Recovering("QTemporaryFile::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_Seek(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) SeekDefault(pos int64) bool {
|
|
defer qt.Recovering("QTemporaryFile::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_SeekDefault(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTemporaryFile_AtEnd
|
|
func callbackQTemporaryFile_AtEnd(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::atEnd")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "atEnd"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTemporaryFileFromPointer(ptr).AtEndDefault()))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectAtEnd(f func() bool) {
|
|
defer qt.Recovering("connect QTemporaryFile::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "atEnd", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectAtEnd() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "atEnd")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) AtEnd() bool {
|
|
defer qt.Recovering("QTemporaryFile::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_AtEnd(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) AtEndDefault() bool {
|
|
defer qt.Recovering("QTemporaryFile::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_AtEndDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTemporaryFile_Close
|
|
func callbackQTemporaryFile_Close(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTemporaryFile::close")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQTemporaryFileFromPointer(ptr).CloseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectClose(f func()) {
|
|
defer qt.Recovering("connect QTemporaryFile::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "close", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectClose() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "close")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) Close() {
|
|
defer qt.Recovering("QTemporaryFile::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_Close(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) CloseDefault() {
|
|
defer qt.Recovering("QTemporaryFile::close")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_CloseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQTemporaryFile_IsSequential
|
|
func callbackQTemporaryFile_IsSequential(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::isSequential")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "isSequential"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTemporaryFileFromPointer(ptr).IsSequentialDefault()))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectIsSequential(f func() bool) {
|
|
defer qt.Recovering("connect QTemporaryFile::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "isSequential", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectIsSequential() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "isSequential")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) IsSequential() bool {
|
|
defer qt.Recovering("QTemporaryFile::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_IsSequential(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) IsSequentialDefault() bool {
|
|
defer qt.Recovering("QTemporaryFile::isSequential")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_IsSequentialDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTemporaryFile_Pos
|
|
func callbackQTemporaryFile_Pos(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QTemporaryFile::pos")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pos"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQTemporaryFileFromPointer(ptr).PosDefault())
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectPos(f func() int64) {
|
|
defer qt.Recovering("connect QTemporaryFile::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pos", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectPos() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pos")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) Pos() int64 {
|
|
defer qt.Recovering("QTemporaryFile::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTemporaryFile_Pos(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) PosDefault() int64 {
|
|
defer qt.Recovering("QTemporaryFile::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTemporaryFile_PosDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQTemporaryFile_ReadLineData
|
|
func callbackQTemporaryFile_ReadLineData(ptr unsafe.Pointer, ptrName *C.char, data *C.char, maxlen C.longlong) C.longlong {
|
|
defer qt.Recovering("callback QTemporaryFile::readLineData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "readLineData"); signal != nil {
|
|
return C.longlong(signal.(func(string, int64) int64)(C.GoString(data), int64(maxlen)))
|
|
}
|
|
|
|
return C.longlong(NewQTemporaryFileFromPointer(ptr).ReadLineDataDefault(C.GoString(data), int64(maxlen)))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectReadLineData(f func(data string, maxlen int64) int64) {
|
|
defer qt.Recovering("connect QTemporaryFile::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "readLineData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectReadLineData() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "readLineData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ReadLineData(data string, maxlen int64) int64 {
|
|
defer qt.Recovering("QTemporaryFile::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTemporaryFile_ReadLineData(ptr.Pointer(), C.CString(data), C.longlong(maxlen)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ReadLineDataDefault(data string, maxlen int64) int64 {
|
|
defer qt.Recovering("QTemporaryFile::readLineData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTemporaryFile_ReadLineDataDefault(ptr.Pointer(), C.CString(data), C.longlong(maxlen)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQTemporaryFile_WriteData
|
|
func callbackQTemporaryFile_WriteData(ptr unsafe.Pointer, ptrName *C.char, data *C.char, len C.longlong) C.longlong {
|
|
defer qt.Recovering("callback QTemporaryFile::writeData")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "writeData"); signal != nil {
|
|
return C.longlong(signal.(func(string, int64) int64)(C.GoString(data), int64(len)))
|
|
}
|
|
|
|
return C.longlong(NewQTemporaryFileFromPointer(ptr).WriteDataDefault(C.GoString(data), int64(len)))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectWriteData(f func(data string, len int64) int64) {
|
|
defer qt.Recovering("connect QTemporaryFile::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "writeData", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectWriteData() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "writeData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) WriteData(data string, len int64) int64 {
|
|
defer qt.Recovering("QTemporaryFile::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTemporaryFile_WriteData(ptr.Pointer(), C.CString(data), C.longlong(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) WriteDataDefault(data string, len int64) int64 {
|
|
defer qt.Recovering("QTemporaryFile::writeData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTemporaryFile_WriteDataDefault(ptr.Pointer(), C.CString(data), C.longlong(len)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQTemporaryFile_BytesAvailable
|
|
func callbackQTemporaryFile_BytesAvailable(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QTemporaryFile::bytesAvailable")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesAvailable"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQTemporaryFileFromPointer(ptr).BytesAvailableDefault())
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectBytesAvailable(f func() int64) {
|
|
defer qt.Recovering("connect QTemporaryFile::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesAvailable", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectBytesAvailable() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) BytesAvailable() int64 {
|
|
defer qt.Recovering("QTemporaryFile::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTemporaryFile_BytesAvailable(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) BytesAvailableDefault() int64 {
|
|
defer qt.Recovering("QTemporaryFile::bytesAvailable")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTemporaryFile_BytesAvailableDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQTemporaryFile_BytesToWrite
|
|
func callbackQTemporaryFile_BytesToWrite(ptr unsafe.Pointer, ptrName *C.char) C.longlong {
|
|
defer qt.Recovering("callback QTemporaryFile::bytesToWrite")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "bytesToWrite"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(NewQTemporaryFileFromPointer(ptr).BytesToWriteDefault())
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectBytesToWrite(f func() int64) {
|
|
defer qt.Recovering("connect QTemporaryFile::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "bytesToWrite", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectBytesToWrite() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "bytesToWrite")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) BytesToWrite() int64 {
|
|
defer qt.Recovering("QTemporaryFile::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTemporaryFile_BytesToWrite(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) BytesToWriteDefault() int64 {
|
|
defer qt.Recovering("QTemporaryFile::bytesToWrite")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTemporaryFile_BytesToWriteDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQTemporaryFile_CanReadLine
|
|
func callbackQTemporaryFile_CanReadLine(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::canReadLine")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "canReadLine"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTemporaryFileFromPointer(ptr).CanReadLineDefault()))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectCanReadLine(f func() bool) {
|
|
defer qt.Recovering("connect QTemporaryFile::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "canReadLine", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectCanReadLine() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "canReadLine")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) CanReadLine() bool {
|
|
defer qt.Recovering("QTemporaryFile::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_CanReadLine(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) CanReadLineDefault() bool {
|
|
defer qt.Recovering("QTemporaryFile::canReadLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_CanReadLineDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTemporaryFile_Reset
|
|
func callbackQTemporaryFile_Reset(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::reset")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "reset"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTemporaryFileFromPointer(ptr).ResetDefault()))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectReset(f func() bool) {
|
|
defer qt.Recovering("connect QTemporaryFile::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "reset", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectReset() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "reset")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) Reset() bool {
|
|
defer qt.Recovering("QTemporaryFile::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_Reset(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ResetDefault() bool {
|
|
defer qt.Recovering("QTemporaryFile::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_ResetDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTemporaryFile_WaitForBytesWritten
|
|
func callbackQTemporaryFile_WaitForBytesWritten(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::waitForBytesWritten")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "waitForBytesWritten"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(msecs))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTemporaryFileFromPointer(ptr).WaitForBytesWrittenDefault(int(msecs))))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectWaitForBytesWritten(f func(msecs int) bool) {
|
|
defer qt.Recovering("connect QTemporaryFile::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "waitForBytesWritten", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectWaitForBytesWritten() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "waitForBytesWritten")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) WaitForBytesWritten(msecs int) bool {
|
|
defer qt.Recovering("QTemporaryFile::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_WaitForBytesWritten(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) WaitForBytesWrittenDefault(msecs int) bool {
|
|
defer qt.Recovering("QTemporaryFile::waitForBytesWritten")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_WaitForBytesWrittenDefault(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTemporaryFile_WaitForReadyRead
|
|
func callbackQTemporaryFile_WaitForReadyRead(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::waitForReadyRead")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "waitForReadyRead"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(int) bool)(int(msecs))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTemporaryFileFromPointer(ptr).WaitForReadyReadDefault(int(msecs))))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectWaitForReadyRead(f func(msecs int) bool) {
|
|
defer qt.Recovering("connect QTemporaryFile::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "waitForReadyRead", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectWaitForReadyRead() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "waitForReadyRead")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) WaitForReadyRead(msecs int) bool {
|
|
defer qt.Recovering("QTemporaryFile::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_WaitForReadyRead(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) WaitForReadyReadDefault(msecs int) bool {
|
|
defer qt.Recovering("QTemporaryFile::waitForReadyRead")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_WaitForReadyReadDefault(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTemporaryFile_TimerEvent
|
|
func callbackQTemporaryFile_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTemporaryFile::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQTemporaryFileFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QTemporaryFile::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QTemporaryFile::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QTemporaryFile::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQTemporaryFile_ChildEvent
|
|
func callbackQTemporaryFile_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTemporaryFile::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQTemporaryFileFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QTemporaryFile::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QTemporaryFile::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QTemporaryFile::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQTemporaryFile_ConnectNotify
|
|
func callbackQTemporaryFile_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTemporaryFile::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQTemporaryFileFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QTemporaryFile::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTemporaryFile::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTemporaryFile::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQTemporaryFile_CustomEvent
|
|
func callbackQTemporaryFile_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTemporaryFile::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQTemporaryFileFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QTemporaryFile::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QTemporaryFile::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QTemporaryFile::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQTemporaryFile_DeleteLater
|
|
func callbackQTemporaryFile_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTemporaryFile::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQTemporaryFileFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QTemporaryFile::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DeleteLater() {
|
|
defer qt.Recovering("QTemporaryFile::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QTemporaryFile_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DeleteLaterDefault() {
|
|
defer qt.Recovering("QTemporaryFile::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QTemporaryFile_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQTemporaryFile_DisconnectNotify
|
|
func callbackQTemporaryFile_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTemporaryFile::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQTemporaryFileFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QTemporaryFile::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTemporaryFile::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTemporaryFile::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTemporaryFile_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQTemporaryFile_Event
|
|
func callbackQTemporaryFile_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTemporaryFileFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QTemporaryFile::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QTemporaryFile::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QTemporaryFile::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTemporaryFile_EventFilter
|
|
func callbackQTemporaryFile_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QTemporaryFile::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTemporaryFileFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QTemporaryFile::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QTemporaryFile::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QTemporaryFile::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTemporaryFile_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTemporaryFile_MetaObject
|
|
func callbackQTemporaryFile_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QTemporaryFile::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQTemporaryFileFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QTemporaryFile::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QTemporaryFile::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QTemporaryFile::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QTemporaryFile_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QTemporaryFile) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QTemporaryFile::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QTemporaryFile_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//QTextBoundaryFinder::BoundaryReason
|
|
type QTextBoundaryFinder__BoundaryReason int64
|
|
|
|
const (
|
|
QTextBoundaryFinder__NotAtBoundary = QTextBoundaryFinder__BoundaryReason(0)
|
|
QTextBoundaryFinder__BreakOpportunity = QTextBoundaryFinder__BoundaryReason(0x1f)
|
|
QTextBoundaryFinder__StartOfItem = QTextBoundaryFinder__BoundaryReason(0x20)
|
|
QTextBoundaryFinder__EndOfItem = QTextBoundaryFinder__BoundaryReason(0x40)
|
|
QTextBoundaryFinder__MandatoryBreak = QTextBoundaryFinder__BoundaryReason(0x80)
|
|
QTextBoundaryFinder__SoftHyphen = QTextBoundaryFinder__BoundaryReason(0x100)
|
|
)
|
|
|
|
//QTextBoundaryFinder::BoundaryType
|
|
type QTextBoundaryFinder__BoundaryType int64
|
|
|
|
const (
|
|
QTextBoundaryFinder__Grapheme = QTextBoundaryFinder__BoundaryType(0)
|
|
QTextBoundaryFinder__Word = QTextBoundaryFinder__BoundaryType(1)
|
|
QTextBoundaryFinder__Sentence = QTextBoundaryFinder__BoundaryType(2)
|
|
QTextBoundaryFinder__Line = QTextBoundaryFinder__BoundaryType(3)
|
|
)
|
|
|
|
type QTextBoundaryFinder struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QTextBoundaryFinder_ITF interface {
|
|
QTextBoundaryFinder_PTR() *QTextBoundaryFinder
|
|
}
|
|
|
|
func (p *QTextBoundaryFinder) QTextBoundaryFinder_PTR() *QTextBoundaryFinder {
|
|
return p
|
|
}
|
|
|
|
func (p *QTextBoundaryFinder) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTextBoundaryFinder) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQTextBoundaryFinder(ptr QTextBoundaryFinder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTextBoundaryFinder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTextBoundaryFinderFromPointer(ptr unsafe.Pointer) *QTextBoundaryFinder {
|
|
var n = new(QTextBoundaryFinder)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTextBoundaryFinderFromPointer(ptr unsafe.Pointer) *QTextBoundaryFinder {
|
|
var n = NewQTextBoundaryFinderFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQTextBoundaryFinder() *QTextBoundaryFinder {
|
|
defer qt.Recovering("QTextBoundaryFinder::QTextBoundaryFinder")
|
|
|
|
return newQTextBoundaryFinderFromPointer(C.QTextBoundaryFinder_NewQTextBoundaryFinder())
|
|
}
|
|
|
|
func NewQTextBoundaryFinder3(ty QTextBoundaryFinder__BoundaryType, stri string) *QTextBoundaryFinder {
|
|
defer qt.Recovering("QTextBoundaryFinder::QTextBoundaryFinder")
|
|
|
|
return newQTextBoundaryFinderFromPointer(C.QTextBoundaryFinder_NewQTextBoundaryFinder3(C.int(ty), C.CString(stri)))
|
|
}
|
|
|
|
func NewQTextBoundaryFinder2(other QTextBoundaryFinder_ITF) *QTextBoundaryFinder {
|
|
defer qt.Recovering("QTextBoundaryFinder::QTextBoundaryFinder")
|
|
|
|
return newQTextBoundaryFinderFromPointer(C.QTextBoundaryFinder_NewQTextBoundaryFinder2(PointerFromQTextBoundaryFinder(other)))
|
|
}
|
|
|
|
func (ptr *QTextBoundaryFinder) BoundaryReasons() QTextBoundaryFinder__BoundaryReason {
|
|
defer qt.Recovering("QTextBoundaryFinder::boundaryReasons")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QTextBoundaryFinder__BoundaryReason(C.QTextBoundaryFinder_BoundaryReasons(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextBoundaryFinder) IsAtBoundary() bool {
|
|
defer qt.Recovering("QTextBoundaryFinder::isAtBoundary")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTextBoundaryFinder_IsAtBoundary(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTextBoundaryFinder) IsValid() bool {
|
|
defer qt.Recovering("QTextBoundaryFinder::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTextBoundaryFinder_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTextBoundaryFinder) Position() int {
|
|
defer qt.Recovering("QTextBoundaryFinder::position")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTextBoundaryFinder_Position(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextBoundaryFinder) SetPosition(position int) {
|
|
defer qt.Recovering("QTextBoundaryFinder::setPosition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextBoundaryFinder_SetPosition(ptr.Pointer(), C.int(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextBoundaryFinder) String() string {
|
|
defer qt.Recovering("QTextBoundaryFinder::string")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextBoundaryFinder_String(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextBoundaryFinder) ToEnd() {
|
|
defer qt.Recovering("QTextBoundaryFinder::toEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextBoundaryFinder_ToEnd(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextBoundaryFinder) ToNextBoundary() int {
|
|
defer qt.Recovering("QTextBoundaryFinder::toNextBoundary")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTextBoundaryFinder_ToNextBoundary(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextBoundaryFinder) ToPreviousBoundary() int {
|
|
defer qt.Recovering("QTextBoundaryFinder::toPreviousBoundary")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTextBoundaryFinder_ToPreviousBoundary(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextBoundaryFinder) ToStart() {
|
|
defer qt.Recovering("QTextBoundaryFinder::toStart")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextBoundaryFinder_ToStart(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextBoundaryFinder) Type() QTextBoundaryFinder__BoundaryType {
|
|
defer qt.Recovering("QTextBoundaryFinder::type")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QTextBoundaryFinder__BoundaryType(C.QTextBoundaryFinder_Type(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextBoundaryFinder) DestroyQTextBoundaryFinder() {
|
|
defer qt.Recovering("QTextBoundaryFinder::~QTextBoundaryFinder")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextBoundaryFinder_DestroyQTextBoundaryFinder(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QTextCodec::ConversionFlag
|
|
type QTextCodec__ConversionFlag int64
|
|
|
|
const (
|
|
QTextCodec__DefaultConversion = QTextCodec__ConversionFlag(0)
|
|
QTextCodec__ConvertInvalidToNull = QTextCodec__ConversionFlag(0x80000000)
|
|
QTextCodec__IgnoreHeader = QTextCodec__ConversionFlag(0x1)
|
|
QTextCodec__FreeFunction = QTextCodec__ConversionFlag(0x2)
|
|
)
|
|
|
|
type QTextCodec struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QTextCodec_ITF interface {
|
|
QTextCodec_PTR() *QTextCodec
|
|
}
|
|
|
|
func (p *QTextCodec) QTextCodec_PTR() *QTextCodec {
|
|
return p
|
|
}
|
|
|
|
func (p *QTextCodec) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTextCodec) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQTextCodec(ptr QTextCodec_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTextCodec_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTextCodecFromPointer(ptr unsafe.Pointer) *QTextCodec {
|
|
var n = new(QTextCodec)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTextCodecFromPointer(ptr unsafe.Pointer) *QTextCodec {
|
|
var n = NewQTextCodecFromPointer(ptr)
|
|
for len(n.ObjectNameAbs()) < len("QTextCodec_") {
|
|
n.SetObjectNameAbs("QTextCodec_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QTextCodec) CanEncode(ch QChar_ITF) bool {
|
|
defer qt.Recovering("QTextCodec::canEncode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTextCodec_CanEncode(ptr.Pointer(), PointerFromQChar(ch)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTextCodec) CanEncode2(s string) bool {
|
|
defer qt.Recovering("QTextCodec::canEncode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTextCodec_CanEncode2(ptr.Pointer(), C.CString(s)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QTextCodec_CodecForHtml2(ba string) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForHtml")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForHtml2(C.CString(ba)))
|
|
}
|
|
|
|
func (ptr *QTextCodec) CodecForHtml2(ba string) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForHtml")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForHtml2(C.CString(ba)))
|
|
}
|
|
|
|
func QTextCodec_CodecForHtml(ba string, defaultCodec QTextCodec_ITF) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForHtml")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForHtml(C.CString(ba), PointerFromQTextCodec(defaultCodec)))
|
|
}
|
|
|
|
func (ptr *QTextCodec) CodecForHtml(ba string, defaultCodec QTextCodec_ITF) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForHtml")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForHtml(C.CString(ba), PointerFromQTextCodec(defaultCodec)))
|
|
}
|
|
|
|
func QTextCodec_CodecForLocale() *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForLocale")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForLocale())
|
|
}
|
|
|
|
func (ptr *QTextCodec) CodecForLocale() *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForLocale")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForLocale())
|
|
}
|
|
|
|
func QTextCodec_CodecForMib(mib int) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForMib")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForMib(C.int(mib)))
|
|
}
|
|
|
|
func (ptr *QTextCodec) CodecForMib(mib int) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForMib")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForMib(C.int(mib)))
|
|
}
|
|
|
|
func QTextCodec_CodecForName(name string) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForName")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForName(C.CString(name)))
|
|
}
|
|
|
|
func (ptr *QTextCodec) CodecForName(name string) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForName")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForName(C.CString(name)))
|
|
}
|
|
|
|
func QTextCodec_CodecForName2(name string) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForName")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForName2(C.CString(name)))
|
|
}
|
|
|
|
func (ptr *QTextCodec) CodecForName2(name string) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForName")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForName2(C.CString(name)))
|
|
}
|
|
|
|
func QTextCodec_CodecForUtfText2(ba string) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForUtfText")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForUtfText2(C.CString(ba)))
|
|
}
|
|
|
|
func (ptr *QTextCodec) CodecForUtfText2(ba string) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForUtfText")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForUtfText2(C.CString(ba)))
|
|
}
|
|
|
|
func QTextCodec_CodecForUtfText(ba string, defaultCodec QTextCodec_ITF) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForUtfText")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForUtfText(C.CString(ba), PointerFromQTextCodec(defaultCodec)))
|
|
}
|
|
|
|
func (ptr *QTextCodec) CodecForUtfText(ba string, defaultCodec QTextCodec_ITF) *QTextCodec {
|
|
defer qt.Recovering("QTextCodec::codecForUtfText")
|
|
|
|
return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForUtfText(C.CString(ba), PointerFromQTextCodec(defaultCodec)))
|
|
}
|
|
|
|
func (ptr *QTextCodec) FromUnicode(str string) string {
|
|
defer qt.Recovering("QTextCodec::fromUnicode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextCodec_FromUnicode(ptr.Pointer(), C.CString(str)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextCodec) MakeDecoder(flags QTextCodec__ConversionFlag) *QTextDecoder {
|
|
defer qt.Recovering("QTextCodec::makeDecoder")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQTextDecoderFromPointer(C.QTextCodec_MakeDecoder(ptr.Pointer(), C.int(flags)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QTextCodec) MakeEncoder(flags QTextCodec__ConversionFlag) *QTextEncoder {
|
|
defer qt.Recovering("QTextCodec::makeEncoder")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQTextEncoderFromPointer(C.QTextCodec_MakeEncoder(ptr.Pointer(), C.int(flags)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQTextCodec_MibEnum
|
|
func callbackQTextCodec_MibEnum(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QTextCodec::mibEnum")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "mibEnum"); signal != nil {
|
|
return C.int(signal.(func() int)())
|
|
}
|
|
|
|
return C.int(0)
|
|
}
|
|
|
|
func (ptr *QTextCodec) ConnectMibEnum(f func() int) {
|
|
defer qt.Recovering("connect QTextCodec::mibEnum")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectNameAbs(), "mibEnum", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextCodec) DisconnectMibEnum() {
|
|
defer qt.Recovering("disconnect QTextCodec::mibEnum")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectNameAbs(), "mibEnum")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextCodec) MibEnum() int {
|
|
defer qt.Recovering("QTextCodec::mibEnum")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTextCodec_MibEnum(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQTextCodec_Name
|
|
func callbackQTextCodec_Name(ptr unsafe.Pointer, ptrName *C.char) *C.char {
|
|
defer qt.Recovering("callback QTextCodec::name")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "name"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QTextCodec) ConnectName(f func() string) {
|
|
defer qt.Recovering("connect QTextCodec::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectNameAbs(), "name", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextCodec) DisconnectName() {
|
|
defer qt.Recovering("disconnect QTextCodec::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectNameAbs(), "name")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextCodec) Name() string {
|
|
defer qt.Recovering("QTextCodec::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextCodec_Name(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func QTextCodec_SetCodecForLocale(c QTextCodec_ITF) {
|
|
defer qt.Recovering("QTextCodec::setCodecForLocale")
|
|
|
|
C.QTextCodec_QTextCodec_SetCodecForLocale(PointerFromQTextCodec(c))
|
|
}
|
|
|
|
func (ptr *QTextCodec) SetCodecForLocale(c QTextCodec_ITF) {
|
|
defer qt.Recovering("QTextCodec::setCodecForLocale")
|
|
|
|
C.QTextCodec_QTextCodec_SetCodecForLocale(PointerFromQTextCodec(c))
|
|
}
|
|
|
|
func (ptr *QTextCodec) ToUnicode(a string) string {
|
|
defer qt.Recovering("QTextCodec::toUnicode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextCodec_ToUnicode(ptr.Pointer(), C.CString(a)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextCodec) ToUnicode2(chars string) string {
|
|
defer qt.Recovering("QTextCodec::toUnicode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextCodec_ToUnicode2(ptr.Pointer(), C.CString(chars)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextCodec) DestroyQTextCodec() {
|
|
defer qt.Recovering("QTextCodec::~QTextCodec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectNameAbs())
|
|
C.QTextCodec_DestroyQTextCodec(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextCodec) ObjectNameAbs() string {
|
|
defer qt.Recovering("QTextCodec::objectNameAbs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextCodec_ObjectNameAbs(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextCodec) SetObjectNameAbs(name string) {
|
|
defer qt.Recovering("QTextCodec::setObjectNameAbs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextCodec_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
|
|
}
|
|
}
|
|
|
|
type QTextDecoder struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QTextDecoder_ITF interface {
|
|
QTextDecoder_PTR() *QTextDecoder
|
|
}
|
|
|
|
func (p *QTextDecoder) QTextDecoder_PTR() *QTextDecoder {
|
|
return p
|
|
}
|
|
|
|
func (p *QTextDecoder) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTextDecoder) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQTextDecoder(ptr QTextDecoder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTextDecoder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTextDecoderFromPointer(ptr unsafe.Pointer) *QTextDecoder {
|
|
var n = new(QTextDecoder)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTextDecoderFromPointer(ptr unsafe.Pointer) *QTextDecoder {
|
|
var n = NewQTextDecoderFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QTextDecoder) ToUnicode(chars string, len int) string {
|
|
defer qt.Recovering("QTextDecoder::toUnicode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextDecoder_ToUnicode(ptr.Pointer(), C.CString(chars), C.int(len)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func NewQTextDecoder(codec QTextCodec_ITF) *QTextDecoder {
|
|
defer qt.Recovering("QTextDecoder::QTextDecoder")
|
|
|
|
return newQTextDecoderFromPointer(C.QTextDecoder_NewQTextDecoder(PointerFromQTextCodec(codec)))
|
|
}
|
|
|
|
func NewQTextDecoder2(codec QTextCodec_ITF, flags QTextCodec__ConversionFlag) *QTextDecoder {
|
|
defer qt.Recovering("QTextDecoder::QTextDecoder")
|
|
|
|
return newQTextDecoderFromPointer(C.QTextDecoder_NewQTextDecoder2(PointerFromQTextCodec(codec), C.int(flags)))
|
|
}
|
|
|
|
func (ptr *QTextDecoder) ToUnicode2(ba string) string {
|
|
defer qt.Recovering("QTextDecoder::toUnicode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextDecoder_ToUnicode2(ptr.Pointer(), C.CString(ba)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextDecoder) ToUnicode3(target string, chars string, len int) {
|
|
defer qt.Recovering("QTextDecoder::toUnicode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextDecoder_ToUnicode3(ptr.Pointer(), C.CString(target), C.CString(chars), C.int(len))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextDecoder) DestroyQTextDecoder() {
|
|
defer qt.Recovering("QTextDecoder::~QTextDecoder")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextDecoder_DestroyQTextDecoder(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QTextEncoder struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QTextEncoder_ITF interface {
|
|
QTextEncoder_PTR() *QTextEncoder
|
|
}
|
|
|
|
func (p *QTextEncoder) QTextEncoder_PTR() *QTextEncoder {
|
|
return p
|
|
}
|
|
|
|
func (p *QTextEncoder) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTextEncoder) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQTextEncoder(ptr QTextEncoder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTextEncoder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTextEncoderFromPointer(ptr unsafe.Pointer) *QTextEncoder {
|
|
var n = new(QTextEncoder)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTextEncoderFromPointer(ptr unsafe.Pointer) *QTextEncoder {
|
|
var n = NewQTextEncoderFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQTextEncoder(codec QTextCodec_ITF) *QTextEncoder {
|
|
defer qt.Recovering("QTextEncoder::QTextEncoder")
|
|
|
|
return newQTextEncoderFromPointer(C.QTextEncoder_NewQTextEncoder(PointerFromQTextCodec(codec)))
|
|
}
|
|
|
|
func NewQTextEncoder2(codec QTextCodec_ITF, flags QTextCodec__ConversionFlag) *QTextEncoder {
|
|
defer qt.Recovering("QTextEncoder::QTextEncoder")
|
|
|
|
return newQTextEncoderFromPointer(C.QTextEncoder_NewQTextEncoder2(PointerFromQTextCodec(codec), C.int(flags)))
|
|
}
|
|
|
|
func (ptr *QTextEncoder) FromUnicode2(uc QChar_ITF, len int) string {
|
|
defer qt.Recovering("QTextEncoder::fromUnicode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextEncoder_FromUnicode2(ptr.Pointer(), PointerFromQChar(uc), C.int(len)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextEncoder) FromUnicode(str string) string {
|
|
defer qt.Recovering("QTextEncoder::fromUnicode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextEncoder_FromUnicode(ptr.Pointer(), C.CString(str)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextEncoder) DestroyQTextEncoder() {
|
|
defer qt.Recovering("QTextEncoder::~QTextEncoder")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextEncoder_DestroyQTextEncoder(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QTextStream::FieldAlignment
|
|
type QTextStream__FieldAlignment int64
|
|
|
|
const (
|
|
QTextStream__AlignLeft = QTextStream__FieldAlignment(0)
|
|
QTextStream__AlignRight = QTextStream__FieldAlignment(1)
|
|
QTextStream__AlignCenter = QTextStream__FieldAlignment(2)
|
|
QTextStream__AlignAccountingStyle = QTextStream__FieldAlignment(3)
|
|
)
|
|
|
|
//QTextStream::NumberFlag
|
|
type QTextStream__NumberFlag int64
|
|
|
|
const (
|
|
QTextStream__ShowBase = QTextStream__NumberFlag(0x1)
|
|
QTextStream__ForcePoint = QTextStream__NumberFlag(0x2)
|
|
QTextStream__ForceSign = QTextStream__NumberFlag(0x4)
|
|
QTextStream__UppercaseBase = QTextStream__NumberFlag(0x8)
|
|
QTextStream__UppercaseDigits = QTextStream__NumberFlag(0x10)
|
|
)
|
|
|
|
//QTextStream::RealNumberNotation
|
|
type QTextStream__RealNumberNotation int64
|
|
|
|
const (
|
|
QTextStream__SmartNotation = QTextStream__RealNumberNotation(0)
|
|
QTextStream__FixedNotation = QTextStream__RealNumberNotation(1)
|
|
QTextStream__ScientificNotation = QTextStream__RealNumberNotation(2)
|
|
)
|
|
|
|
//QTextStream::Status
|
|
type QTextStream__Status int64
|
|
|
|
const (
|
|
QTextStream__Ok = QTextStream__Status(0)
|
|
QTextStream__ReadPastEnd = QTextStream__Status(1)
|
|
QTextStream__ReadCorruptData = QTextStream__Status(2)
|
|
QTextStream__WriteFailed = QTextStream__Status(3)
|
|
)
|
|
|
|
type QTextStream struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QTextStream_ITF interface {
|
|
QTextStream_PTR() *QTextStream
|
|
}
|
|
|
|
func (p *QTextStream) QTextStream_PTR() *QTextStream {
|
|
return p
|
|
}
|
|
|
|
func (p *QTextStream) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTextStream) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQTextStream(ptr QTextStream_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTextStream_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTextStreamFromPointer(ptr unsafe.Pointer) *QTextStream {
|
|
var n = new(QTextStream)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTextStreamFromPointer(ptr unsafe.Pointer) *QTextStream {
|
|
var n = NewQTextStreamFromPointer(ptr)
|
|
for len(n.ObjectNameAbs()) < len("QTextStream_") {
|
|
n.SetObjectNameAbs("QTextStream_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQTextStream() *QTextStream {
|
|
defer qt.Recovering("QTextStream::QTextStream")
|
|
|
|
return newQTextStreamFromPointer(C.QTextStream_NewQTextStream())
|
|
}
|
|
|
|
func NewQTextStream5(array string, openMode QIODevice__OpenModeFlag) *QTextStream {
|
|
defer qt.Recovering("QTextStream::QTextStream")
|
|
|
|
return newQTextStreamFromPointer(C.QTextStream_NewQTextStream5(C.CString(array), C.int(openMode)))
|
|
}
|
|
|
|
func NewQTextStream2(device QIODevice_ITF) *QTextStream {
|
|
defer qt.Recovering("QTextStream::QTextStream")
|
|
|
|
return newQTextStreamFromPointer(C.QTextStream_NewQTextStream2(PointerFromQIODevice(device)))
|
|
}
|
|
|
|
func NewQTextStream4(stri string, openMode QIODevice__OpenModeFlag) *QTextStream {
|
|
defer qt.Recovering("QTextStream::QTextStream")
|
|
|
|
return newQTextStreamFromPointer(C.QTextStream_NewQTextStream4(C.CString(stri), C.int(openMode)))
|
|
}
|
|
|
|
func NewQTextStream6(array string, openMode QIODevice__OpenModeFlag) *QTextStream {
|
|
defer qt.Recovering("QTextStream::QTextStream")
|
|
|
|
return newQTextStreamFromPointer(C.QTextStream_NewQTextStream6(C.CString(array), C.int(openMode)))
|
|
}
|
|
|
|
func (ptr *QTextStream) AtEnd() bool {
|
|
defer qt.Recovering("QTextStream::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTextStream_AtEnd(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTextStream) AutoDetectUnicode() bool {
|
|
defer qt.Recovering("QTextStream::autoDetectUnicode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTextStream_AutoDetectUnicode(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTextStream) Codec() *QTextCodec {
|
|
defer qt.Recovering("QTextStream::codec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQTextCodecFromPointer(C.QTextStream_Codec(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QTextStream) Device() *QIODevice {
|
|
defer qt.Recovering("QTextStream::device")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQIODeviceFromPointer(C.QTextStream_Device(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QTextStream) FieldAlignment() QTextStream__FieldAlignment {
|
|
defer qt.Recovering("QTextStream::fieldAlignment")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QTextStream__FieldAlignment(C.QTextStream_FieldAlignment(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextStream) FieldWidth() int {
|
|
defer qt.Recovering("QTextStream::fieldWidth")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTextStream_FieldWidth(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextStream) Flush() {
|
|
defer qt.Recovering("QTextStream::flush")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_Flush(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) GenerateByteOrderMark() bool {
|
|
defer qt.Recovering("QTextStream::generateByteOrderMark")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTextStream_GenerateByteOrderMark(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTextStream) IntegerBase() int {
|
|
defer qt.Recovering("QTextStream::integerBase")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTextStream_IntegerBase(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextStream) Locale() *QLocale {
|
|
defer qt.Recovering("QTextStream::locale")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLocaleFromPointer(C.QTextStream_Locale(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QTextStream) NumberFlags() QTextStream__NumberFlag {
|
|
defer qt.Recovering("QTextStream::numberFlags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QTextStream__NumberFlag(C.QTextStream_NumberFlags(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextStream) Pos() int64 {
|
|
defer qt.Recovering("QTextStream::pos")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QTextStream_Pos(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextStream) Read(maxlen int64) string {
|
|
defer qt.Recovering("QTextStream::read")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextStream_Read(ptr.Pointer(), C.longlong(maxlen)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextStream) ReadAll() string {
|
|
defer qt.Recovering("QTextStream::readAll")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextStream_ReadAll(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextStream) ReadLine(maxlen int64) string {
|
|
defer qt.Recovering("QTextStream::readLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextStream_ReadLine(ptr.Pointer(), C.longlong(maxlen)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextStream) ReadLineInto(line string, maxlen int64) bool {
|
|
defer qt.Recovering("QTextStream::readLineInto")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTextStream_ReadLineInto(ptr.Pointer(), C.CString(line), C.longlong(maxlen)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTextStream) RealNumberNotation() QTextStream__RealNumberNotation {
|
|
defer qt.Recovering("QTextStream::realNumberNotation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QTextStream__RealNumberNotation(C.QTextStream_RealNumberNotation(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextStream) RealNumberPrecision() int {
|
|
defer qt.Recovering("QTextStream::realNumberPrecision")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTextStream_RealNumberPrecision(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextStream) Reset() {
|
|
defer qt.Recovering("QTextStream::reset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_Reset(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) ResetStatus() {
|
|
defer qt.Recovering("QTextStream::resetStatus")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_ResetStatus(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) Seek(pos int64) bool {
|
|
defer qt.Recovering("QTextStream::seek")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTextStream_Seek(ptr.Pointer(), C.longlong(pos)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTextStream) SetAutoDetectUnicode(enabled bool) {
|
|
defer qt.Recovering("QTextStream::setAutoDetectUnicode")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetAutoDetectUnicode(ptr.Pointer(), C.int(qt.GoBoolToInt(enabled)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetCodec(codec QTextCodec_ITF) {
|
|
defer qt.Recovering("QTextStream::setCodec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetCodec(ptr.Pointer(), PointerFromQTextCodec(codec))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetCodec2(codecName string) {
|
|
defer qt.Recovering("QTextStream::setCodec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetCodec2(ptr.Pointer(), C.CString(codecName))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetDevice(device QIODevice_ITF) {
|
|
defer qt.Recovering("QTextStream::setDevice")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetDevice(ptr.Pointer(), PointerFromQIODevice(device))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetFieldAlignment(mode QTextStream__FieldAlignment) {
|
|
defer qt.Recovering("QTextStream::setFieldAlignment")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetFieldAlignment(ptr.Pointer(), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetFieldWidth(width int) {
|
|
defer qt.Recovering("QTextStream::setFieldWidth")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetFieldWidth(ptr.Pointer(), C.int(width))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetGenerateByteOrderMark(generate bool) {
|
|
defer qt.Recovering("QTextStream::setGenerateByteOrderMark")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetGenerateByteOrderMark(ptr.Pointer(), C.int(qt.GoBoolToInt(generate)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetIntegerBase(base int) {
|
|
defer qt.Recovering("QTextStream::setIntegerBase")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetIntegerBase(ptr.Pointer(), C.int(base))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetLocale(locale QLocale_ITF) {
|
|
defer qt.Recovering("QTextStream::setLocale")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetLocale(ptr.Pointer(), PointerFromQLocale(locale))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetNumberFlags(flags QTextStream__NumberFlag) {
|
|
defer qt.Recovering("QTextStream::setNumberFlags")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetNumberFlags(ptr.Pointer(), C.int(flags))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetPadChar(ch QChar_ITF) {
|
|
defer qt.Recovering("QTextStream::setPadChar")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetPadChar(ptr.Pointer(), PointerFromQChar(ch))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetRealNumberNotation(notation QTextStream__RealNumberNotation) {
|
|
defer qt.Recovering("QTextStream::setRealNumberNotation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetRealNumberNotation(ptr.Pointer(), C.int(notation))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetRealNumberPrecision(precision int) {
|
|
defer qt.Recovering("QTextStream::setRealNumberPrecision")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetRealNumberPrecision(ptr.Pointer(), C.int(precision))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetStatus(status QTextStream__Status) {
|
|
defer qt.Recovering("QTextStream::setStatus")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetStatus(ptr.Pointer(), C.int(status))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SetString(stri string, openMode QIODevice__OpenModeFlag) {
|
|
defer qt.Recovering("QTextStream::setString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetString(ptr.Pointer(), C.CString(stri), C.int(openMode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) SkipWhiteSpace() {
|
|
defer qt.Recovering("QTextStream::skipWhiteSpace")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SkipWhiteSpace(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) Status() QTextStream__Status {
|
|
defer qt.Recovering("QTextStream::status")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QTextStream__Status(C.QTextStream_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTextStream) String() string {
|
|
defer qt.Recovering("QTextStream::string")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextStream_String(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextStream) DestroyQTextStream() {
|
|
defer qt.Recovering("QTextStream::~QTextStream")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectNameAbs())
|
|
C.QTextStream_DestroyQTextStream(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTextStream) ObjectNameAbs() string {
|
|
defer qt.Recovering("QTextStream::objectNameAbs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTextStream_ObjectNameAbs(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTextStream) SetObjectNameAbs(name string) {
|
|
defer qt.Recovering("QTextStream::setObjectNameAbs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTextStream_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
|
|
}
|
|
}
|
|
|
|
//QThread::Priority
|
|
type QThread__Priority int64
|
|
|
|
const (
|
|
QThread__IdlePriority = QThread__Priority(0)
|
|
QThread__LowestPriority = QThread__Priority(1)
|
|
QThread__LowPriority = QThread__Priority(2)
|
|
QThread__NormalPriority = QThread__Priority(3)
|
|
QThread__HighPriority = QThread__Priority(4)
|
|
QThread__HighestPriority = QThread__Priority(5)
|
|
QThread__TimeCriticalPriority = QThread__Priority(6)
|
|
QThread__InheritPriority = QThread__Priority(7)
|
|
)
|
|
|
|
type QThread struct {
|
|
QObject
|
|
}
|
|
|
|
type QThread_ITF interface {
|
|
QObject_ITF
|
|
QThread_PTR() *QThread
|
|
}
|
|
|
|
func (p *QThread) QThread_PTR() *QThread {
|
|
return p
|
|
}
|
|
|
|
func (p *QThread) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QThread) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQThread(ptr QThread_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QThread_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQThreadFromPointer(ptr unsafe.Pointer) *QThread {
|
|
var n = new(QThread)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQThreadFromPointer(ptr unsafe.Pointer) *QThread {
|
|
var n = NewQThreadFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QThread_") {
|
|
n.SetObjectName("QThread_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QThread) SetPriority(priority QThread__Priority) {
|
|
defer qt.Recovering("QThread::setPriority")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_SetPriority(ptr.Pointer(), C.int(priority))
|
|
}
|
|
}
|
|
|
|
func NewQThread(parent QObject_ITF) *QThread {
|
|
defer qt.Recovering("QThread::QThread")
|
|
|
|
return newQThreadFromPointer(C.QThread_NewQThread(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func QThread_CurrentThread() *QThread {
|
|
defer qt.Recovering("QThread::currentThread")
|
|
|
|
return NewQThreadFromPointer(C.QThread_QThread_CurrentThread())
|
|
}
|
|
|
|
func (ptr *QThread) CurrentThread() *QThread {
|
|
defer qt.Recovering("QThread::currentThread")
|
|
|
|
return NewQThreadFromPointer(C.QThread_QThread_CurrentThread())
|
|
}
|
|
|
|
//export callbackQThread_Event
|
|
func callbackQThread_Event(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QThread::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQThreadFromPointer(ptr).EventDefault(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QThread) ConnectEvent(f func(event *QEvent) bool) {
|
|
defer qt.Recovering("connect QThread::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QThread::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) Event(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QThread::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThread_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QThread) EventDefault(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QThread::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThread_EventDefault(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QThread) EventDispatcher() *QAbstractEventDispatcher {
|
|
defer qt.Recovering("QThread::eventDispatcher")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractEventDispatcherFromPointer(C.QThread_EventDispatcher(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QThread) Exec() int {
|
|
defer qt.Recovering("QThread::exec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QThread_Exec(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QThread) Exit(returnCode int) {
|
|
defer qt.Recovering("QThread::exit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_Exit(ptr.Pointer(), C.int(returnCode))
|
|
}
|
|
}
|
|
|
|
//export callbackQThread_Finished
|
|
func callbackQThread_Finished(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QThread::finished")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "finished"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QThread) ConnectFinished(f func()) {
|
|
defer qt.Recovering("connect QThread::finished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_ConnectFinished(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "finished", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectFinished() {
|
|
defer qt.Recovering("disconnect QThread::finished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_DisconnectFinished(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "finished")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) IsFinished() bool {
|
|
defer qt.Recovering("QThread::isFinished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThread_IsFinished(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QThread) IsInterruptionRequested() bool {
|
|
defer qt.Recovering("QThread::isInterruptionRequested")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThread_IsInterruptionRequested(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QThread) IsRunning() bool {
|
|
defer qt.Recovering("QThread::isRunning")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThread_IsRunning(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QThread) LoopLevel() int {
|
|
defer qt.Recovering("QThread::loopLevel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QThread_LoopLevel(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QThread) Priority() QThread__Priority {
|
|
defer qt.Recovering("QThread::priority")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QThread__Priority(C.QThread_Priority(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQThread_Quit
|
|
func callbackQThread_Quit(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QThread::quit")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "quit"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QThread) ConnectQuit(f func()) {
|
|
defer qt.Recovering("connect QThread::quit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "quit", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectQuit() {
|
|
defer qt.Recovering("disconnect QThread::quit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "quit")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) Quit() {
|
|
defer qt.Recovering("QThread::quit")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_Quit(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) RequestInterruption() {
|
|
defer qt.Recovering("QThread::requestInterruption")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_RequestInterruption(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQThread_Run
|
|
func callbackQThread_Run(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QThread::run")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "run"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQThreadFromPointer(ptr).RunDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) ConnectRun(f func()) {
|
|
defer qt.Recovering("connect QThread::run")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "run", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectRun() {
|
|
defer qt.Recovering("disconnect QThread::run")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "run")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) Run() {
|
|
defer qt.Recovering("QThread::run")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_Run(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) RunDefault() {
|
|
defer qt.Recovering("QThread::run")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_RunDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) SetEventDispatcher(eventDispatcher QAbstractEventDispatcher_ITF) {
|
|
defer qt.Recovering("QThread::setEventDispatcher")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_SetEventDispatcher(ptr.Pointer(), PointerFromQAbstractEventDispatcher(eventDispatcher))
|
|
}
|
|
}
|
|
|
|
//export callbackQThread_Started
|
|
func callbackQThread_Started(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QThread::started")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "started"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QThread) ConnectStarted(f func()) {
|
|
defer qt.Recovering("connect QThread::started")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_ConnectStarted(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "started", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectStarted() {
|
|
defer qt.Recovering("disconnect QThread::started")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_DisconnectStarted(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "started")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DestroyQThread() {
|
|
defer qt.Recovering("QThread::~QThread")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QThread_DestroyQThread(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func QThread_IdealThreadCount() int {
|
|
defer qt.Recovering("QThread::idealThreadCount")
|
|
|
|
return int(C.QThread_QThread_IdealThreadCount())
|
|
}
|
|
|
|
func (ptr *QThread) IdealThreadCount() int {
|
|
defer qt.Recovering("QThread::idealThreadCount")
|
|
|
|
return int(C.QThread_QThread_IdealThreadCount())
|
|
}
|
|
|
|
func QThread_SetTerminationEnabled(enabled bool) {
|
|
defer qt.Recovering("QThread::setTerminationEnabled")
|
|
|
|
C.QThread_QThread_SetTerminationEnabled(C.int(qt.GoBoolToInt(enabled)))
|
|
}
|
|
|
|
func (ptr *QThread) SetTerminationEnabled(enabled bool) {
|
|
defer qt.Recovering("QThread::setTerminationEnabled")
|
|
|
|
C.QThread_QThread_SetTerminationEnabled(C.int(qt.GoBoolToInt(enabled)))
|
|
}
|
|
|
|
//export callbackQThread_Start
|
|
func callbackQThread_Start(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QThread::start")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "start"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QThread) ConnectStart(f func()) {
|
|
defer qt.Recovering("connect QThread::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "start", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectStart() {
|
|
defer qt.Recovering("disconnect QThread::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) Start() {
|
|
defer qt.Recovering("QThread::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_Start(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQThread_Terminate
|
|
func callbackQThread_Terminate(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QThread::terminate")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "terminate"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QThread) ConnectTerminate(f func()) {
|
|
defer qt.Recovering("connect QThread::terminate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "terminate", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectTerminate() {
|
|
defer qt.Recovering("disconnect QThread::terminate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "terminate")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) Terminate() {
|
|
defer qt.Recovering("QThread::terminate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_Terminate(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func QThread_YieldCurrentThread() {
|
|
defer qt.Recovering("QThread::yieldCurrentThread")
|
|
|
|
C.QThread_QThread_YieldCurrentThread()
|
|
}
|
|
|
|
func (ptr *QThread) YieldCurrentThread() {
|
|
defer qt.Recovering("QThread::yieldCurrentThread")
|
|
|
|
C.QThread_QThread_YieldCurrentThread()
|
|
}
|
|
|
|
//export callbackQThread_TimerEvent
|
|
func callbackQThread_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QThread::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQThreadFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QThread::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QThread::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QThread::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QThread::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQThread_ChildEvent
|
|
func callbackQThread_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QThread::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQThreadFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QThread::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QThread::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QThread::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QThread::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQThread_ConnectNotify
|
|
func callbackQThread_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QThread::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQThreadFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QThread::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QThread::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QThread::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QThread::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQThread_CustomEvent
|
|
func callbackQThread_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QThread::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQThreadFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QThread::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QThread::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QThread::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QThread::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQThread_DeleteLater
|
|
func callbackQThread_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QThread::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQThreadFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QThread::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QThread::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DeleteLater() {
|
|
defer qt.Recovering("QThread::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QThread_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DeleteLaterDefault() {
|
|
defer qt.Recovering("QThread::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QThread_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQThread_DisconnectNotify
|
|
func callbackQThread_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QThread::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQThreadFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QThread::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QThread::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QThread::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QThread::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThread_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQThread_EventFilter
|
|
func callbackQThread_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QThread::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQThreadFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QThread) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QThread::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QThread::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QThread::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThread_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QThread) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QThread::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThread_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQThread_MetaObject
|
|
func callbackQThread_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QThread::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQThreadFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QThread) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QThread::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QThread::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThread) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QThread::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QThread_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QThread) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QThread::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QThread_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QThreadPool struct {
|
|
QObject
|
|
}
|
|
|
|
type QThreadPool_ITF interface {
|
|
QObject_ITF
|
|
QThreadPool_PTR() *QThreadPool
|
|
}
|
|
|
|
func (p *QThreadPool) QThreadPool_PTR() *QThreadPool {
|
|
return p
|
|
}
|
|
|
|
func (p *QThreadPool) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QThreadPool) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQThreadPool(ptr QThreadPool_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QThreadPool_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQThreadPoolFromPointer(ptr unsafe.Pointer) *QThreadPool {
|
|
var n = new(QThreadPool)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQThreadPoolFromPointer(ptr unsafe.Pointer) *QThreadPool {
|
|
var n = NewQThreadPoolFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QThreadPool_") {
|
|
n.SetObjectName("QThreadPool_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QThreadPool) ActiveThreadCount() int {
|
|
defer qt.Recovering("QThreadPool::activeThreadCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QThreadPool_ActiveThreadCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QThreadPool) ExpiryTimeout() int {
|
|
defer qt.Recovering("QThreadPool::expiryTimeout")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QThreadPool_ExpiryTimeout(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QThreadPool) MaxThreadCount() int {
|
|
defer qt.Recovering("QThreadPool::maxThreadCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QThreadPool_MaxThreadCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QThreadPool) SetExpiryTimeout(expiryTimeout int) {
|
|
defer qt.Recovering("QThreadPool::setExpiryTimeout")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_SetExpiryTimeout(ptr.Pointer(), C.int(expiryTimeout))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) SetMaxThreadCount(maxThreadCount int) {
|
|
defer qt.Recovering("QThreadPool::setMaxThreadCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_SetMaxThreadCount(ptr.Pointer(), C.int(maxThreadCount))
|
|
}
|
|
}
|
|
|
|
func NewQThreadPool(parent QObject_ITF) *QThreadPool {
|
|
defer qt.Recovering("QThreadPool::QThreadPool")
|
|
|
|
return newQThreadPoolFromPointer(C.QThreadPool_NewQThreadPool(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QThreadPool) Cancel(runnable QRunnable_ITF) {
|
|
defer qt.Recovering("QThreadPool::cancel")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_Cancel(ptr.Pointer(), PointerFromQRunnable(runnable))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) Clear() {
|
|
defer qt.Recovering("QThreadPool::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func QThreadPool_GlobalInstance() *QThreadPool {
|
|
defer qt.Recovering("QThreadPool::globalInstance")
|
|
|
|
return NewQThreadPoolFromPointer(C.QThreadPool_QThreadPool_GlobalInstance())
|
|
}
|
|
|
|
func (ptr *QThreadPool) GlobalInstance() *QThreadPool {
|
|
defer qt.Recovering("QThreadPool::globalInstance")
|
|
|
|
return NewQThreadPoolFromPointer(C.QThreadPool_QThreadPool_GlobalInstance())
|
|
}
|
|
|
|
func (ptr *QThreadPool) ReleaseThread() {
|
|
defer qt.Recovering("QThreadPool::releaseThread")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_ReleaseThread(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) ReserveThread() {
|
|
defer qt.Recovering("QThreadPool::reserveThread")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_ReserveThread(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) Start(runnable QRunnable_ITF, priority int) {
|
|
defer qt.Recovering("QThreadPool::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_Start(ptr.Pointer(), PointerFromQRunnable(runnable), C.int(priority))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) TryStart(runnable QRunnable_ITF) bool {
|
|
defer qt.Recovering("QThreadPool::tryStart")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThreadPool_TryStart(ptr.Pointer(), PointerFromQRunnable(runnable)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QThreadPool) WaitForDone(msecs int) bool {
|
|
defer qt.Recovering("QThreadPool::waitForDone")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThreadPool_WaitForDone(ptr.Pointer(), C.int(msecs)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QThreadPool) DestroyQThreadPool() {
|
|
defer qt.Recovering("QThreadPool::~QThreadPool")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_DestroyQThreadPool(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQThreadPool_TimerEvent
|
|
func callbackQThreadPool_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QThreadPool::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQThreadPoolFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QThreadPool::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QThreadPool::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QThreadPool::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QThreadPool::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQThreadPool_ChildEvent
|
|
func callbackQThreadPool_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QThreadPool::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQThreadPoolFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QThreadPool::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QThreadPool::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QThreadPool::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QThreadPool::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQThreadPool_ConnectNotify
|
|
func callbackQThreadPool_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QThreadPool::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQThreadPoolFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QThreadPool::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QThreadPool::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QThreadPool::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QThreadPool::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQThreadPool_CustomEvent
|
|
func callbackQThreadPool_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QThreadPool::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQThreadPoolFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QThreadPool::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QThreadPool::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QThreadPool::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QThreadPool::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQThreadPool_DeleteLater
|
|
func callbackQThreadPool_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QThreadPool::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQThreadPoolFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QThreadPool::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QThreadPool::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DeleteLater() {
|
|
defer qt.Recovering("QThreadPool::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DeleteLaterDefault() {
|
|
defer qt.Recovering("QThreadPool::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQThreadPool_DisconnectNotify
|
|
func callbackQThreadPool_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QThreadPool::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQThreadPoolFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QThreadPool::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QThreadPool::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QThreadPool::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QThreadPool::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QThreadPool_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQThreadPool_Event
|
|
func callbackQThreadPool_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QThreadPool::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQThreadPoolFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QThreadPool) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QThreadPool::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QThreadPool::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QThreadPool::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThreadPool_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QThreadPool) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QThreadPool::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThreadPool_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQThreadPool_EventFilter
|
|
func callbackQThreadPool_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QThreadPool::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQThreadPoolFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QThreadPool) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QThreadPool::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QThreadPool::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QThreadPool::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThreadPool_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QThreadPool) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QThreadPool::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QThreadPool_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQThreadPool_MetaObject
|
|
func callbackQThreadPool_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QThreadPool::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQThreadPoolFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QThreadPool) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QThreadPool::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QThreadPool::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QThreadPool) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QThreadPool::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QThreadPool_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QThreadPool) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QThreadPool::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QThreadPool_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QThreadStorage struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QThreadStorage_ITF interface {
|
|
QThreadStorage_PTR() *QThreadStorage
|
|
}
|
|
|
|
func (p *QThreadStorage) QThreadStorage_PTR() *QThreadStorage {
|
|
return p
|
|
}
|
|
|
|
func (p *QThreadStorage) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QThreadStorage) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQThreadStorage(ptr QThreadStorage_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QThreadStorage_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQThreadStorageFromPointer(ptr unsafe.Pointer) *QThreadStorage {
|
|
var n = new(QThreadStorage)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQThreadStorageFromPointer(ptr unsafe.Pointer) *QThreadStorage {
|
|
var n = NewQThreadStorageFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QTime struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QTime_ITF interface {
|
|
QTime_PTR() *QTime
|
|
}
|
|
|
|
func (p *QTime) QTime_PTR() *QTime {
|
|
return p
|
|
}
|
|
|
|
func (p *QTime) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTime) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQTime(ptr QTime_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTime_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTimeFromPointer(ptr unsafe.Pointer) *QTime {
|
|
var n = new(QTime)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTimeFromPointer(ptr unsafe.Pointer) *QTime {
|
|
var n = NewQTimeFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQTime() *QTime {
|
|
defer qt.Recovering("QTime::QTime")
|
|
|
|
return newQTimeFromPointer(C.QTime_NewQTime())
|
|
}
|
|
|
|
func NewQTime3(h int, m int, s int, ms int) *QTime {
|
|
defer qt.Recovering("QTime::QTime")
|
|
|
|
return newQTimeFromPointer(C.QTime_NewQTime3(C.int(h), C.int(m), C.int(s), C.int(ms)))
|
|
}
|
|
|
|
func (ptr *QTime) Elapsed() int {
|
|
defer qt.Recovering("QTime::elapsed")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTime_Elapsed(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTime) Hour() int {
|
|
defer qt.Recovering("QTime::hour")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTime_Hour(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTime) IsNull() bool {
|
|
defer qt.Recovering("QTime::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTime_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QTime_IsValid2(h int, m int, s int, ms int) bool {
|
|
defer qt.Recovering("QTime::isValid")
|
|
|
|
return C.QTime_QTime_IsValid2(C.int(h), C.int(m), C.int(s), C.int(ms)) != 0
|
|
}
|
|
|
|
func (ptr *QTime) IsValid2(h int, m int, s int, ms int) bool {
|
|
defer qt.Recovering("QTime::isValid")
|
|
|
|
return C.QTime_QTime_IsValid2(C.int(h), C.int(m), C.int(s), C.int(ms)) != 0
|
|
}
|
|
|
|
func (ptr *QTime) IsValid() bool {
|
|
defer qt.Recovering("QTime::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTime_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTime) Minute() int {
|
|
defer qt.Recovering("QTime::minute")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTime_Minute(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTime) Msec() int {
|
|
defer qt.Recovering("QTime::msec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTime_Msec(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTime) MsecsSinceStartOfDay() int {
|
|
defer qt.Recovering("QTime::msecsSinceStartOfDay")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTime_MsecsSinceStartOfDay(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTime) MsecsTo(t QTime_ITF) int {
|
|
defer qt.Recovering("QTime::msecsTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTime_MsecsTo(ptr.Pointer(), PointerFromQTime(t)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTime) Restart() int {
|
|
defer qt.Recovering("QTime::restart")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTime_Restart(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTime) Second() int {
|
|
defer qt.Recovering("QTime::second")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTime_Second(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTime) SecsTo(t QTime_ITF) int {
|
|
defer qt.Recovering("QTime::secsTo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTime_SecsTo(ptr.Pointer(), PointerFromQTime(t)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTime) SetHMS(h int, m int, s int, ms int) bool {
|
|
defer qt.Recovering("QTime::setHMS")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTime_SetHMS(ptr.Pointer(), C.int(h), C.int(m), C.int(s), C.int(ms)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTime) Start() {
|
|
defer qt.Recovering("QTime::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTime_Start(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QTime) ToString2(format Qt__DateFormat) string {
|
|
defer qt.Recovering("QTime::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTime_ToString2(ptr.Pointer(), C.int(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTime) ToString(format string) string {
|
|
defer qt.Recovering("QTime::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTime_ToString(ptr.Pointer(), C.CString(format)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//QTimeLine::CurveShape
|
|
type QTimeLine__CurveShape int64
|
|
|
|
const (
|
|
QTimeLine__EaseInCurve = QTimeLine__CurveShape(0)
|
|
QTimeLine__EaseOutCurve = QTimeLine__CurveShape(1)
|
|
QTimeLine__EaseInOutCurve = QTimeLine__CurveShape(2)
|
|
QTimeLine__LinearCurve = QTimeLine__CurveShape(3)
|
|
QTimeLine__SineCurve = QTimeLine__CurveShape(4)
|
|
QTimeLine__CosineCurve = QTimeLine__CurveShape(5)
|
|
)
|
|
|
|
//QTimeLine::Direction
|
|
type QTimeLine__Direction int64
|
|
|
|
const (
|
|
QTimeLine__Forward = QTimeLine__Direction(0)
|
|
QTimeLine__Backward = QTimeLine__Direction(1)
|
|
)
|
|
|
|
//QTimeLine::State
|
|
type QTimeLine__State int64
|
|
|
|
const (
|
|
QTimeLine__NotRunning = QTimeLine__State(0)
|
|
QTimeLine__Paused = QTimeLine__State(1)
|
|
QTimeLine__Running = QTimeLine__State(2)
|
|
)
|
|
|
|
type QTimeLine struct {
|
|
QObject
|
|
}
|
|
|
|
type QTimeLine_ITF interface {
|
|
QObject_ITF
|
|
QTimeLine_PTR() *QTimeLine
|
|
}
|
|
|
|
func (p *QTimeLine) QTimeLine_PTR() *QTimeLine {
|
|
return p
|
|
}
|
|
|
|
func (p *QTimeLine) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTimeLine) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQTimeLine(ptr QTimeLine_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTimeLine_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTimeLineFromPointer(ptr unsafe.Pointer) *QTimeLine {
|
|
var n = new(QTimeLine)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTimeLineFromPointer(ptr unsafe.Pointer) *QTimeLine {
|
|
var n = NewQTimeLineFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QTimeLine_") {
|
|
n.SetObjectName("QTimeLine_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QTimeLine) CurrentTime() int {
|
|
defer qt.Recovering("QTimeLine::currentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimeLine_CurrentTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeLine) CurveShape() QTimeLine__CurveShape {
|
|
defer qt.Recovering("QTimeLine::curveShape")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QTimeLine__CurveShape(C.QTimeLine_CurveShape(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeLine) Direction() QTimeLine__Direction {
|
|
defer qt.Recovering("QTimeLine::direction")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QTimeLine__Direction(C.QTimeLine_Direction(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeLine) Duration() int {
|
|
defer qt.Recovering("QTimeLine::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimeLine_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeLine) EasingCurve() *QEasingCurve {
|
|
defer qt.Recovering("QTimeLine::easingCurve")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQEasingCurveFromPointer(C.QTimeLine_EasingCurve(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QTimeLine) LoopCount() int {
|
|
defer qt.Recovering("QTimeLine::loopCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimeLine_LoopCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQTimeLine_SetCurrentTime
|
|
func callbackQTimeLine_SetCurrentTime(ptr unsafe.Pointer, ptrName *C.char, msec C.int) {
|
|
defer qt.Recovering("callback QTimeLine::setCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(msec))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectSetCurrentTime(f func(msec int)) {
|
|
defer qt.Recovering("connect QTimeLine::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectSetCurrentTime(msec int) {
|
|
defer qt.Recovering("disconnect QTimeLine::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) SetCurrentTime(msec int) {
|
|
defer qt.Recovering("QTimeLine::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_SetCurrentTime(ptr.Pointer(), C.int(msec))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) SetCurveShape(shape QTimeLine__CurveShape) {
|
|
defer qt.Recovering("QTimeLine::setCurveShape")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_SetCurveShape(ptr.Pointer(), C.int(shape))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) SetDirection(direction QTimeLine__Direction) {
|
|
defer qt.Recovering("QTimeLine::setDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_SetDirection(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) SetDuration(duration int) {
|
|
defer qt.Recovering("QTimeLine::setDuration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_SetDuration(ptr.Pointer(), C.int(duration))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) SetEasingCurve(curve QEasingCurve_ITF) {
|
|
defer qt.Recovering("QTimeLine::setEasingCurve")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_SetEasingCurve(ptr.Pointer(), PointerFromQEasingCurve(curve))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) SetLoopCount(count int) {
|
|
defer qt.Recovering("QTimeLine::setLoopCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_SetLoopCount(ptr.Pointer(), C.int(count))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) SetUpdateInterval(interval int) {
|
|
defer qt.Recovering("QTimeLine::setUpdateInterval")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_SetUpdateInterval(ptr.Pointer(), C.int(interval))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) UpdateInterval() int {
|
|
defer qt.Recovering("QTimeLine::updateInterval")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimeLine_UpdateInterval(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func NewQTimeLine(duration int, parent QObject_ITF) *QTimeLine {
|
|
defer qt.Recovering("QTimeLine::QTimeLine")
|
|
|
|
return newQTimeLineFromPointer(C.QTimeLine_NewQTimeLine(C.int(duration), PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QTimeLine) CurrentFrame() int {
|
|
defer qt.Recovering("QTimeLine::currentFrame")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimeLine_CurrentFrame(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeLine) CurrentValue() float64 {
|
|
defer qt.Recovering("QTimeLine::currentValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QTimeLine_CurrentValue(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeLine) EndFrame() int {
|
|
defer qt.Recovering("QTimeLine::endFrame")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimeLine_EndFrame(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQTimeLine_Finished
|
|
func callbackQTimeLine_Finished(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTimeLine::finished")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "finished"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectFinished(f func()) {
|
|
defer qt.Recovering("connect QTimeLine::finished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_ConnectFinished(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "finished", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectFinished() {
|
|
defer qt.Recovering("disconnect QTimeLine::finished")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_DisconnectFinished(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "finished")
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_FrameChanged
|
|
func callbackQTimeLine_FrameChanged(ptr unsafe.Pointer, ptrName *C.char, frame C.int) {
|
|
defer qt.Recovering("callback QTimeLine::frameChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "frameChanged"); signal != nil {
|
|
signal.(func(int))(int(frame))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectFrameChanged(f func(frame int)) {
|
|
defer qt.Recovering("connect QTimeLine::frameChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_ConnectFrameChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "frameChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectFrameChanged() {
|
|
defer qt.Recovering("disconnect QTimeLine::frameChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_DisconnectFrameChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "frameChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) FrameForTime(msec int) int {
|
|
defer qt.Recovering("QTimeLine::frameForTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimeLine_FrameForTime(ptr.Pointer(), C.int(msec)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQTimeLine_Resume
|
|
func callbackQTimeLine_Resume(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTimeLine::resume")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resume"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectResume(f func()) {
|
|
defer qt.Recovering("connect QTimeLine::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resume", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectResume() {
|
|
defer qt.Recovering("disconnect QTimeLine::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) Resume() {
|
|
defer qt.Recovering("QTimeLine::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_Resume(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) SetEndFrame(frame int) {
|
|
defer qt.Recovering("QTimeLine::setEndFrame")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_SetEndFrame(ptr.Pointer(), C.int(frame))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) SetFrameRange(startFrame int, endFrame int) {
|
|
defer qt.Recovering("QTimeLine::setFrameRange")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_SetFrameRange(ptr.Pointer(), C.int(startFrame), C.int(endFrame))
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_SetPaused
|
|
func callbackQTimeLine_SetPaused(ptr unsafe.Pointer, ptrName *C.char, paused C.int) {
|
|
defer qt.Recovering("callback QTimeLine::setPaused")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setPaused"); signal != nil {
|
|
signal.(func(bool))(int(paused) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectSetPaused(f func(paused bool)) {
|
|
defer qt.Recovering("connect QTimeLine::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setPaused", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectSetPaused(paused bool) {
|
|
defer qt.Recovering("disconnect QTimeLine::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setPaused")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) SetPaused(paused bool) {
|
|
defer qt.Recovering("QTimeLine::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_SetPaused(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) SetStartFrame(frame int) {
|
|
defer qt.Recovering("QTimeLine::setStartFrame")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_SetStartFrame(ptr.Pointer(), C.int(frame))
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_Start
|
|
func callbackQTimeLine_Start(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTimeLine::start")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "start"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectStart(f func()) {
|
|
defer qt.Recovering("connect QTimeLine::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "start", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectStart() {
|
|
defer qt.Recovering("disconnect QTimeLine::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) Start() {
|
|
defer qt.Recovering("QTimeLine::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_Start(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) StartFrame() int {
|
|
defer qt.Recovering("QTimeLine::startFrame")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimeLine_StartFrame(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeLine) State() QTimeLine__State {
|
|
defer qt.Recovering("QTimeLine::state")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QTimeLine__State(C.QTimeLine_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQTimeLine_StateChanged
|
|
func callbackQTimeLine_StateChanged(ptr unsafe.Pointer, ptrName *C.char, newState C.int) {
|
|
defer qt.Recovering("callback QTimeLine::stateChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stateChanged"); signal != nil {
|
|
signal.(func(QTimeLine__State))(QTimeLine__State(newState))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectStateChanged(f func(newState QTimeLine__State)) {
|
|
defer qt.Recovering("connect QTimeLine::stateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_ConnectStateChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "stateChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectStateChanged() {
|
|
defer qt.Recovering("disconnect QTimeLine::stateChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stateChanged")
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_Stop
|
|
func callbackQTimeLine_Stop(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTimeLine::stop")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stop"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectStop(f func()) {
|
|
defer qt.Recovering("connect QTimeLine::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "stop", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectStop() {
|
|
defer qt.Recovering("disconnect QTimeLine::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) Stop() {
|
|
defer qt.Recovering("QTimeLine::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_TimerEvent
|
|
func callbackQTimeLine_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTimeLine::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQTimeLineFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QTimeLine::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QTimeLine::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QTimeLine::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QTimeLine::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_ToggleDirection
|
|
func callbackQTimeLine_ToggleDirection(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTimeLine::toggleDirection")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "toggleDirection"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectToggleDirection(f func()) {
|
|
defer qt.Recovering("connect QTimeLine::toggleDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "toggleDirection", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectToggleDirection() {
|
|
defer qt.Recovering("disconnect QTimeLine::toggleDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "toggleDirection")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) ToggleDirection() {
|
|
defer qt.Recovering("QTimeLine::toggleDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_ToggleDirection(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_ValueChanged
|
|
func callbackQTimeLine_ValueChanged(ptr unsafe.Pointer, ptrName *C.char, value C.double) {
|
|
defer qt.Recovering("callback QTimeLine::valueChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "valueChanged"); signal != nil {
|
|
signal.(func(float64))(float64(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectValueChanged(f func(value float64)) {
|
|
defer qt.Recovering("connect QTimeLine::valueChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_ConnectValueChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "valueChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectValueChanged() {
|
|
defer qt.Recovering("disconnect QTimeLine::valueChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_DisconnectValueChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "valueChanged")
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_ValueForTime
|
|
func callbackQTimeLine_ValueForTime(ptr unsafe.Pointer, ptrName *C.char, msec C.int) C.double {
|
|
defer qt.Recovering("callback QTimeLine::valueForTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "valueForTime"); signal != nil {
|
|
return C.double(signal.(func(int) float64)(int(msec)))
|
|
}
|
|
|
|
return C.double(NewQTimeLineFromPointer(ptr).ValueForTimeDefault(int(msec)))
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectValueForTime(f func(msec int) float64) {
|
|
defer qt.Recovering("connect QTimeLine::valueForTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "valueForTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectValueForTime() {
|
|
defer qt.Recovering("disconnect QTimeLine::valueForTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "valueForTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) ValueForTime(msec int) float64 {
|
|
defer qt.Recovering("QTimeLine::valueForTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QTimeLine_ValueForTime(ptr.Pointer(), C.int(msec)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeLine) ValueForTimeDefault(msec int) float64 {
|
|
defer qt.Recovering("QTimeLine::valueForTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QTimeLine_ValueForTimeDefault(ptr.Pointer(), C.int(msec)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeLine) DestroyQTimeLine() {
|
|
defer qt.Recovering("QTimeLine::~QTimeLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QTimeLine_DestroyQTimeLine(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_ChildEvent
|
|
func callbackQTimeLine_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTimeLine::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQTimeLineFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QTimeLine::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QTimeLine::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QTimeLine::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QTimeLine::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_ConnectNotify
|
|
func callbackQTimeLine_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTimeLine::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQTimeLineFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QTimeLine::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QTimeLine::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTimeLine::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTimeLine::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_CustomEvent
|
|
func callbackQTimeLine_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTimeLine::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQTimeLineFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QTimeLine::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QTimeLine::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QTimeLine::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QTimeLine::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_DeleteLater
|
|
func callbackQTimeLine_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTimeLine::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQTimeLineFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QTimeLine::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QTimeLine::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DeleteLater() {
|
|
defer qt.Recovering("QTimeLine::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QTimeLine_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DeleteLaterDefault() {
|
|
defer qt.Recovering("QTimeLine::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QTimeLine_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_DisconnectNotify
|
|
func callbackQTimeLine_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTimeLine::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQTimeLineFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QTimeLine::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QTimeLine::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTimeLine::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTimeLine::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeLine_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQTimeLine_Event
|
|
func callbackQTimeLine_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QTimeLine::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTimeLineFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QTimeLine::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QTimeLine::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QTimeLine::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimeLine_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTimeLine) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QTimeLine::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimeLine_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTimeLine_EventFilter
|
|
func callbackQTimeLine_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QTimeLine::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTimeLineFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QTimeLine::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QTimeLine::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QTimeLine::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimeLine_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTimeLine) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QTimeLine::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimeLine_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTimeLine_MetaObject
|
|
func callbackQTimeLine_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QTimeLine::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQTimeLineFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QTimeLine) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QTimeLine::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QTimeLine::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimeLine) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QTimeLine::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QTimeLine_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QTimeLine) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QTimeLine::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QTimeLine_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//QTimeZone::NameType
|
|
type QTimeZone__NameType int64
|
|
|
|
const (
|
|
QTimeZone__DefaultName = QTimeZone__NameType(0)
|
|
QTimeZone__LongName = QTimeZone__NameType(1)
|
|
QTimeZone__ShortName = QTimeZone__NameType(2)
|
|
QTimeZone__OffsetName = QTimeZone__NameType(3)
|
|
)
|
|
|
|
//QTimeZone::TimeType
|
|
type QTimeZone__TimeType int64
|
|
|
|
const (
|
|
QTimeZone__StandardTime = QTimeZone__TimeType(0)
|
|
QTimeZone__DaylightTime = QTimeZone__TimeType(1)
|
|
QTimeZone__GenericTime = QTimeZone__TimeType(2)
|
|
)
|
|
|
|
type QTimeZone struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QTimeZone_ITF interface {
|
|
QTimeZone_PTR() *QTimeZone
|
|
}
|
|
|
|
func (p *QTimeZone) QTimeZone_PTR() *QTimeZone {
|
|
return p
|
|
}
|
|
|
|
func (p *QTimeZone) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTimeZone) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQTimeZone(ptr QTimeZone_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTimeZone_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTimeZoneFromPointer(ptr unsafe.Pointer) *QTimeZone {
|
|
var n = new(QTimeZone)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTimeZoneFromPointer(ptr unsafe.Pointer) *QTimeZone {
|
|
var n = NewQTimeZoneFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQTimeZone() *QTimeZone {
|
|
defer qt.Recovering("QTimeZone::QTimeZone")
|
|
|
|
return newQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone())
|
|
}
|
|
|
|
func NewQTimeZone2(ianaId string) *QTimeZone {
|
|
defer qt.Recovering("QTimeZone::QTimeZone")
|
|
|
|
return newQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone2(C.CString(ianaId)))
|
|
}
|
|
|
|
func NewQTimeZone4(ianaId string, offsetSeconds int, name string, abbreviation string, country QLocale__Country, comment string) *QTimeZone {
|
|
defer qt.Recovering("QTimeZone::QTimeZone")
|
|
|
|
return newQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone4(C.CString(ianaId), C.int(offsetSeconds), C.CString(name), C.CString(abbreviation), C.int(country), C.CString(comment)))
|
|
}
|
|
|
|
func NewQTimeZone5(other QTimeZone_ITF) *QTimeZone {
|
|
defer qt.Recovering("QTimeZone::QTimeZone")
|
|
|
|
return newQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone5(PointerFromQTimeZone(other)))
|
|
}
|
|
|
|
func NewQTimeZone3(offsetSeconds int) *QTimeZone {
|
|
defer qt.Recovering("QTimeZone::QTimeZone")
|
|
|
|
return newQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone3(C.int(offsetSeconds)))
|
|
}
|
|
|
|
func (ptr *QTimeZone) Abbreviation(atDateTime QDateTime_ITF) string {
|
|
defer qt.Recovering("QTimeZone::abbreviation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTimeZone_Abbreviation(ptr.Pointer(), PointerFromQDateTime(atDateTime)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTimeZone) Comment() string {
|
|
defer qt.Recovering("QTimeZone::comment")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTimeZone_Comment(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTimeZone) Country() QLocale__Country {
|
|
defer qt.Recovering("QTimeZone::country")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QLocale__Country(C.QTimeZone_Country(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeZone) DaylightTimeOffset(atDateTime QDateTime_ITF) int {
|
|
defer qt.Recovering("QTimeZone::daylightTimeOffset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimeZone_DaylightTimeOffset(ptr.Pointer(), PointerFromQDateTime(atDateTime)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeZone) DisplayName2(timeType QTimeZone__TimeType, nameType QTimeZone__NameType, locale QLocale_ITF) string {
|
|
defer qt.Recovering("QTimeZone::displayName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTimeZone_DisplayName2(ptr.Pointer(), C.int(timeType), C.int(nameType), PointerFromQLocale(locale)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTimeZone) DisplayName(atDateTime QDateTime_ITF, nameType QTimeZone__NameType, locale QLocale_ITF) string {
|
|
defer qt.Recovering("QTimeZone::displayName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTimeZone_DisplayName(ptr.Pointer(), PointerFromQDateTime(atDateTime), C.int(nameType), PointerFromQLocale(locale)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTimeZone) HasDaylightTime() bool {
|
|
defer qt.Recovering("QTimeZone::hasDaylightTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimeZone_HasDaylightTime(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTimeZone) HasTransitions() bool {
|
|
defer qt.Recovering("QTimeZone::hasTransitions")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimeZone_HasTransitions(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QTimeZone_IanaIdToWindowsId(ianaId string) string {
|
|
defer qt.Recovering("QTimeZone::ianaIdToWindowsId")
|
|
|
|
return C.GoString(C.QTimeZone_QTimeZone_IanaIdToWindowsId(C.CString(ianaId)))
|
|
}
|
|
|
|
func (ptr *QTimeZone) IanaIdToWindowsId(ianaId string) string {
|
|
defer qt.Recovering("QTimeZone::ianaIdToWindowsId")
|
|
|
|
return C.GoString(C.QTimeZone_QTimeZone_IanaIdToWindowsId(C.CString(ianaId)))
|
|
}
|
|
|
|
func (ptr *QTimeZone) Id() string {
|
|
defer qt.Recovering("QTimeZone::id")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTimeZone_Id(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTimeZone) IsDaylightTime(atDateTime QDateTime_ITF) bool {
|
|
defer qt.Recovering("QTimeZone::isDaylightTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimeZone_IsDaylightTime(ptr.Pointer(), PointerFromQDateTime(atDateTime)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func QTimeZone_IsTimeZoneIdAvailable(ianaId string) bool {
|
|
defer qt.Recovering("QTimeZone::isTimeZoneIdAvailable")
|
|
|
|
return C.QTimeZone_QTimeZone_IsTimeZoneIdAvailable(C.CString(ianaId)) != 0
|
|
}
|
|
|
|
func (ptr *QTimeZone) IsTimeZoneIdAvailable(ianaId string) bool {
|
|
defer qt.Recovering("QTimeZone::isTimeZoneIdAvailable")
|
|
|
|
return C.QTimeZone_QTimeZone_IsTimeZoneIdAvailable(C.CString(ianaId)) != 0
|
|
}
|
|
|
|
func (ptr *QTimeZone) IsValid() bool {
|
|
defer qt.Recovering("QTimeZone::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimeZone_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTimeZone) OffsetFromUtc(atDateTime QDateTime_ITF) int {
|
|
defer qt.Recovering("QTimeZone::offsetFromUtc")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimeZone_OffsetFromUtc(ptr.Pointer(), PointerFromQDateTime(atDateTime)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeZone) StandardTimeOffset(atDateTime QDateTime_ITF) int {
|
|
defer qt.Recovering("QTimeZone::standardTimeOffset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimeZone_StandardTimeOffset(ptr.Pointer(), PointerFromQDateTime(atDateTime)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimeZone) Swap(other QTimeZone_ITF) {
|
|
defer qt.Recovering("QTimeZone::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeZone_Swap(ptr.Pointer(), PointerFromQTimeZone(other))
|
|
}
|
|
}
|
|
|
|
func QTimeZone_SystemTimeZone() *QTimeZone {
|
|
defer qt.Recovering("QTimeZone::systemTimeZone")
|
|
|
|
return NewQTimeZoneFromPointer(C.QTimeZone_QTimeZone_SystemTimeZone())
|
|
}
|
|
|
|
func (ptr *QTimeZone) SystemTimeZone() *QTimeZone {
|
|
defer qt.Recovering("QTimeZone::systemTimeZone")
|
|
|
|
return NewQTimeZoneFromPointer(C.QTimeZone_QTimeZone_SystemTimeZone())
|
|
}
|
|
|
|
func QTimeZone_SystemTimeZoneId() string {
|
|
defer qt.Recovering("QTimeZone::systemTimeZoneId")
|
|
|
|
return C.GoString(C.QTimeZone_QTimeZone_SystemTimeZoneId())
|
|
}
|
|
|
|
func (ptr *QTimeZone) SystemTimeZoneId() string {
|
|
defer qt.Recovering("QTimeZone::systemTimeZoneId")
|
|
|
|
return C.GoString(C.QTimeZone_QTimeZone_SystemTimeZoneId())
|
|
}
|
|
|
|
func QTimeZone_Utc() *QTimeZone {
|
|
defer qt.Recovering("QTimeZone::utc")
|
|
|
|
return NewQTimeZoneFromPointer(C.QTimeZone_QTimeZone_Utc())
|
|
}
|
|
|
|
func (ptr *QTimeZone) Utc() *QTimeZone {
|
|
defer qt.Recovering("QTimeZone::utc")
|
|
|
|
return NewQTimeZoneFromPointer(C.QTimeZone_QTimeZone_Utc())
|
|
}
|
|
|
|
func QTimeZone_WindowsIdToDefaultIanaId(windowsId string) string {
|
|
defer qt.Recovering("QTimeZone::windowsIdToDefaultIanaId")
|
|
|
|
return C.GoString(C.QTimeZone_QTimeZone_WindowsIdToDefaultIanaId(C.CString(windowsId)))
|
|
}
|
|
|
|
func (ptr *QTimeZone) WindowsIdToDefaultIanaId(windowsId string) string {
|
|
defer qt.Recovering("QTimeZone::windowsIdToDefaultIanaId")
|
|
|
|
return C.GoString(C.QTimeZone_QTimeZone_WindowsIdToDefaultIanaId(C.CString(windowsId)))
|
|
}
|
|
|
|
func QTimeZone_WindowsIdToDefaultIanaId2(windowsId string, country QLocale__Country) string {
|
|
defer qt.Recovering("QTimeZone::windowsIdToDefaultIanaId")
|
|
|
|
return C.GoString(C.QTimeZone_QTimeZone_WindowsIdToDefaultIanaId2(C.CString(windowsId), C.int(country)))
|
|
}
|
|
|
|
func (ptr *QTimeZone) WindowsIdToDefaultIanaId2(windowsId string, country QLocale__Country) string {
|
|
defer qt.Recovering("QTimeZone::windowsIdToDefaultIanaId")
|
|
|
|
return C.GoString(C.QTimeZone_QTimeZone_WindowsIdToDefaultIanaId2(C.CString(windowsId), C.int(country)))
|
|
}
|
|
|
|
func (ptr *QTimeZone) DestroyQTimeZone() {
|
|
defer qt.Recovering("QTimeZone::~QTimeZone")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimeZone_DestroyQTimeZone(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QTimer struct {
|
|
QObject
|
|
}
|
|
|
|
type QTimer_ITF interface {
|
|
QObject_ITF
|
|
QTimer_PTR() *QTimer
|
|
}
|
|
|
|
func (p *QTimer) QTimer_PTR() *QTimer {
|
|
return p
|
|
}
|
|
|
|
func (p *QTimer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTimer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQTimer(ptr QTimer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTimer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTimerFromPointer(ptr unsafe.Pointer) *QTimer {
|
|
var n = new(QTimer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTimerFromPointer(ptr unsafe.Pointer) *QTimer {
|
|
var n = NewQTimerFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QTimer_") {
|
|
n.SetObjectName("QTimer_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QTimer) RemainingTime() int {
|
|
defer qt.Recovering("QTimer::remainingTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimer_RemainingTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimer) SetInterval(msec int) {
|
|
defer qt.Recovering("QTimer::setInterval")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_SetInterval(ptr.Pointer(), C.int(msec))
|
|
}
|
|
}
|
|
|
|
func NewQTimer(parent QObject_ITF) *QTimer {
|
|
defer qt.Recovering("QTimer::QTimer")
|
|
|
|
return newQTimerFromPointer(C.QTimer_NewQTimer(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QTimer) Interval() int {
|
|
defer qt.Recovering("QTimer::interval")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimer_Interval(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimer) IsActive() bool {
|
|
defer qt.Recovering("QTimer::isActive")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimer_IsActive(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTimer) IsSingleShot() bool {
|
|
defer qt.Recovering("QTimer::isSingleShot")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimer_IsSingleShot(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTimer) SetSingleShot(singleShot bool) {
|
|
defer qt.Recovering("QTimer::setSingleShot")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_SetSingleShot(ptr.Pointer(), C.int(qt.GoBoolToInt(singleShot)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) SetTimerType(atype Qt__TimerType) {
|
|
defer qt.Recovering("QTimer::setTimerType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_SetTimerType(ptr.Pointer(), C.int(atype))
|
|
}
|
|
}
|
|
|
|
func QTimer_SingleShot2(msec int, timerType Qt__TimerType, receiver QObject_ITF, member string) {
|
|
defer qt.Recovering("QTimer::singleShot")
|
|
|
|
C.QTimer_QTimer_SingleShot2(C.int(msec), C.int(timerType), PointerFromQObject(receiver), C.CString(member))
|
|
}
|
|
|
|
func (ptr *QTimer) SingleShot2(msec int, timerType Qt__TimerType, receiver QObject_ITF, member string) {
|
|
defer qt.Recovering("QTimer::singleShot")
|
|
|
|
C.QTimer_QTimer_SingleShot2(C.int(msec), C.int(timerType), PointerFromQObject(receiver), C.CString(member))
|
|
}
|
|
|
|
func QTimer_SingleShot(msec int, receiver QObject_ITF, member string) {
|
|
defer qt.Recovering("QTimer::singleShot")
|
|
|
|
C.QTimer_QTimer_SingleShot(C.int(msec), PointerFromQObject(receiver), C.CString(member))
|
|
}
|
|
|
|
func (ptr *QTimer) SingleShot(msec int, receiver QObject_ITF, member string) {
|
|
defer qt.Recovering("QTimer::singleShot")
|
|
|
|
C.QTimer_QTimer_SingleShot(C.int(msec), PointerFromQObject(receiver), C.CString(member))
|
|
}
|
|
|
|
//export callbackQTimer_Start2
|
|
func callbackQTimer_Start2(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTimer::start")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "start2"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectStart2(f func()) {
|
|
defer qt.Recovering("connect QTimer::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "start2", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectStart2() {
|
|
defer qt.Recovering("disconnect QTimer::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "start2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) Start2() {
|
|
defer qt.Recovering("QTimer::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_Start2(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQTimer_Start
|
|
func callbackQTimer_Start(ptr unsafe.Pointer, ptrName *C.char, msec C.int) {
|
|
defer qt.Recovering("callback QTimer::start")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "start"); signal != nil {
|
|
signal.(func(int))(int(msec))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectStart(f func(msec int)) {
|
|
defer qt.Recovering("connect QTimer::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "start", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectStart(msec int) {
|
|
defer qt.Recovering("disconnect QTimer::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) Start(msec int) {
|
|
defer qt.Recovering("QTimer::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_Start(ptr.Pointer(), C.int(msec))
|
|
}
|
|
}
|
|
|
|
//export callbackQTimer_Stop
|
|
func callbackQTimer_Stop(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTimer::stop")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stop"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectStop(f func()) {
|
|
defer qt.Recovering("connect QTimer::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "stop", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectStop() {
|
|
defer qt.Recovering("disconnect QTimer::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) Stop() {
|
|
defer qt.Recovering("QTimer::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQTimer_Timeout
|
|
func callbackQTimer_Timeout(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTimer::timeout")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timeout"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectTimeout(f func()) {
|
|
defer qt.Recovering("connect QTimer::timeout")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_ConnectTimeout(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "timeout", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectTimeout() {
|
|
defer qt.Recovering("disconnect QTimer::timeout")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_DisconnectTimeout(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timeout")
|
|
}
|
|
}
|
|
|
|
//export callbackQTimer_TimerEvent
|
|
func callbackQTimer_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTimer::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(e))
|
|
} else {
|
|
NewQTimerFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectTimerEvent(f func(e *QTimerEvent)) {
|
|
defer qt.Recovering("connect QTimer::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QTimer::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) TimerEvent(e QTimerEvent_ITF) {
|
|
defer qt.Recovering("QTimer::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) TimerEventDefault(e QTimerEvent_ITF) {
|
|
defer qt.Recovering("QTimer::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) TimerId() int {
|
|
defer qt.Recovering("QTimer::timerId")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimer_TimerId(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimer) TimerType() Qt__TimerType {
|
|
defer qt.Recovering("QTimer::timerType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return Qt__TimerType(C.QTimer_TimerType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimer) DestroyQTimer() {
|
|
defer qt.Recovering("QTimer::~QTimer")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QTimer_DestroyQTimer(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQTimer_ChildEvent
|
|
func callbackQTimer_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTimer::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQTimerFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QTimer::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QTimer::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QTimer::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QTimer::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQTimer_ConnectNotify
|
|
func callbackQTimer_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTimer::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQTimerFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QTimer::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QTimer::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTimer::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTimer::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQTimer_CustomEvent
|
|
func callbackQTimer_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTimer::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQTimerFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QTimer::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QTimer::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QTimer::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QTimer::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQTimer_DeleteLater
|
|
func callbackQTimer_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTimer::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQTimerFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QTimer::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QTimer::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DeleteLater() {
|
|
defer qt.Recovering("QTimer::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QTimer_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DeleteLaterDefault() {
|
|
defer qt.Recovering("QTimer::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QTimer_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQTimer_DisconnectNotify
|
|
func callbackQTimer_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTimer::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQTimerFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QTimer::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QTimer::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTimer::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTimer::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimer_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQTimer_Event
|
|
func callbackQTimer_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QTimer::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTimerFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QTimer::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QTimer::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QTimer::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimer_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTimer) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QTimer::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimer_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTimer_EventFilter
|
|
func callbackQTimer_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QTimer::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTimerFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QTimer::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QTimer::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QTimer::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimer_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTimer) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QTimer::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTimer_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTimer_MetaObject
|
|
func callbackQTimer_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QTimer::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQTimerFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QTimer) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QTimer::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QTimer::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTimer) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QTimer::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QTimer_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QTimer) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QTimer::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QTimer_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QTimerEvent struct {
|
|
QEvent
|
|
}
|
|
|
|
type QTimerEvent_ITF interface {
|
|
QEvent_ITF
|
|
QTimerEvent_PTR() *QTimerEvent
|
|
}
|
|
|
|
func (p *QTimerEvent) QTimerEvent_PTR() *QTimerEvent {
|
|
return p
|
|
}
|
|
|
|
func (p *QTimerEvent) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QEvent_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTimerEvent) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QEvent_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQTimerEvent(ptr QTimerEvent_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTimerEvent_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTimerEventFromPointer(ptr unsafe.Pointer) *QTimerEvent {
|
|
var n = new(QTimerEvent)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTimerEventFromPointer(ptr unsafe.Pointer) *QTimerEvent {
|
|
var n = NewQTimerEventFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQTimerEvent(timerId int) *QTimerEvent {
|
|
defer qt.Recovering("QTimerEvent::QTimerEvent")
|
|
|
|
return newQTimerEventFromPointer(C.QTimerEvent_NewQTimerEvent(C.int(timerId)))
|
|
}
|
|
|
|
func (ptr *QTimerEvent) TimerId() int {
|
|
defer qt.Recovering("QTimerEvent::timerId")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimerEvent_TimerId(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimerEvent) Id() int {
|
|
defer qt.Recovering("QTimerEvent::id")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QTimerEvent_Id(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QTimerEvent) SetId(vin int) {
|
|
defer qt.Recovering("QTimerEvent::setId")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTimerEvent_SetId(ptr.Pointer(), C.int(vin))
|
|
}
|
|
}
|
|
|
|
type QTranslator struct {
|
|
QObject
|
|
}
|
|
|
|
type QTranslator_ITF interface {
|
|
QObject_ITF
|
|
QTranslator_PTR() *QTranslator
|
|
}
|
|
|
|
func (p *QTranslator) QTranslator_PTR() *QTranslator {
|
|
return p
|
|
}
|
|
|
|
func (p *QTranslator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QTranslator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQTranslator(ptr QTranslator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QTranslator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQTranslatorFromPointer(ptr unsafe.Pointer) *QTranslator {
|
|
var n = new(QTranslator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQTranslatorFromPointer(ptr unsafe.Pointer) *QTranslator {
|
|
var n = NewQTranslatorFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QTranslator_") {
|
|
n.SetObjectName("QTranslator_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func NewQTranslator(parent QObject_ITF) *QTranslator {
|
|
defer qt.Recovering("QTranslator::QTranslator")
|
|
|
|
return newQTranslatorFromPointer(C.QTranslator_NewQTranslator(PointerFromQObject(parent)))
|
|
}
|
|
|
|
//export callbackQTranslator_IsEmpty
|
|
func callbackQTranslator_IsEmpty(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QTranslator::isEmpty")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "isEmpty"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func() bool)()))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTranslatorFromPointer(ptr).IsEmptyDefault()))
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectIsEmpty(f func() bool) {
|
|
defer qt.Recovering("connect QTranslator::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "isEmpty", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectIsEmpty() {
|
|
defer qt.Recovering("disconnect QTranslator::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "isEmpty")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) IsEmpty() bool {
|
|
defer qt.Recovering("QTranslator::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTranslator_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTranslator) IsEmptyDefault() bool {
|
|
defer qt.Recovering("QTranslator::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTranslator_IsEmptyDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTranslator) Load2(locale QLocale_ITF, filename string, prefix string, directory string, suffix string) bool {
|
|
defer qt.Recovering("QTranslator::load")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTranslator_Load2(ptr.Pointer(), PointerFromQLocale(locale), C.CString(filename), C.CString(prefix), C.CString(directory), C.CString(suffix)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTranslator) Load(filename string, directory string, search_delimiters string, suffix string) bool {
|
|
defer qt.Recovering("QTranslator::load")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTranslator_Load(ptr.Pointer(), C.CString(filename), C.CString(directory), C.CString(search_delimiters), C.CString(suffix)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTranslator_Translate
|
|
func callbackQTranslator_Translate(ptr unsafe.Pointer, ptrName *C.char, context *C.char, sourceText *C.char, disambiguation *C.char, n C.int) *C.char {
|
|
defer qt.Recovering("callback QTranslator::translate")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "translate"); signal != nil {
|
|
return C.CString(signal.(func(string, string, string, int) string)(C.GoString(context), C.GoString(sourceText), C.GoString(disambiguation), int(n)))
|
|
}
|
|
|
|
return C.CString(NewQTranslatorFromPointer(ptr).TranslateDefault(C.GoString(context), C.GoString(sourceText), C.GoString(disambiguation), int(n)))
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectTranslate(f func(context string, sourceText string, disambiguation string, n int) string) {
|
|
defer qt.Recovering("connect QTranslator::translate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "translate", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectTranslate() {
|
|
defer qt.Recovering("disconnect QTranslator::translate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "translate")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) Translate(context string, sourceText string, disambiguation string, n int) string {
|
|
defer qt.Recovering("QTranslator::translate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTranslator_Translate(ptr.Pointer(), C.CString(context), C.CString(sourceText), C.CString(disambiguation), C.int(n)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTranslator) TranslateDefault(context string, sourceText string, disambiguation string, n int) string {
|
|
defer qt.Recovering("QTranslator::translate")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QTranslator_TranslateDefault(ptr.Pointer(), C.CString(context), C.CString(sourceText), C.CString(disambiguation), C.int(n)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QTranslator) DestroyQTranslator() {
|
|
defer qt.Recovering("QTranslator::~QTranslator")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QTranslator_DestroyQTranslator(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQTranslator_TimerEvent
|
|
func callbackQTranslator_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTranslator::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQTranslatorFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QTranslator::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QTranslator::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QTranslator::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTranslator_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QTranslator::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTranslator_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQTranslator_ChildEvent
|
|
func callbackQTranslator_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTranslator::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQTranslatorFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QTranslator::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QTranslator::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QTranslator::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTranslator_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QTranslator::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTranslator_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQTranslator_ConnectNotify
|
|
func callbackQTranslator_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTranslator::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQTranslatorFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QTranslator::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QTranslator::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTranslator::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTranslator_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTranslator::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTranslator_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQTranslator_CustomEvent
|
|
func callbackQTranslator_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTranslator::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQTranslatorFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QTranslator::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QTranslator::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QTranslator::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTranslator_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QTranslator::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTranslator_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQTranslator_DeleteLater
|
|
func callbackQTranslator_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QTranslator::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQTranslatorFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QTranslator::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QTranslator::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DeleteLater() {
|
|
defer qt.Recovering("QTranslator::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QTranslator_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DeleteLaterDefault() {
|
|
defer qt.Recovering("QTranslator::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QTranslator_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQTranslator_DisconnectNotify
|
|
func callbackQTranslator_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QTranslator::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQTranslatorFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QTranslator::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QTranslator::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTranslator::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTranslator_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QTranslator::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QTranslator_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQTranslator_Event
|
|
func callbackQTranslator_Event(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QTranslator::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTranslatorFromPointer(ptr).EventDefault(NewQEventFromPointer(e))))
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectEvent(f func(e *QEvent) bool) {
|
|
defer qt.Recovering("connect QTranslator::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QTranslator::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) Event(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QTranslator::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTranslator_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTranslator) EventDefault(e QEvent_ITF) bool {
|
|
defer qt.Recovering("QTranslator::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTranslator_EventDefault(ptr.Pointer(), PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTranslator_EventFilter
|
|
func callbackQTranslator_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QTranslator::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQTranslatorFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QTranslator::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QTranslator::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QTranslator::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTranslator_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QTranslator) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QTranslator::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QTranslator_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQTranslator_MetaObject
|
|
func callbackQTranslator_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QTranslator::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQTranslatorFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QTranslator) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QTranslator::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QTranslator::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QTranslator) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QTranslator::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QTranslator_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QTranslator) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QTranslator::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QTranslator_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QUnhandledException struct {
|
|
QException
|
|
}
|
|
|
|
type QUnhandledException_ITF interface {
|
|
QException_ITF
|
|
QUnhandledException_PTR() *QUnhandledException
|
|
}
|
|
|
|
func (p *QUnhandledException) QUnhandledException_PTR() *QUnhandledException {
|
|
return p
|
|
}
|
|
|
|
func (p *QUnhandledException) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QException_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QUnhandledException) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QException_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQUnhandledException(ptr QUnhandledException_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QUnhandledException_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQUnhandledExceptionFromPointer(ptr unsafe.Pointer) *QUnhandledException {
|
|
var n = new(QUnhandledException)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQUnhandledExceptionFromPointer(ptr unsafe.Pointer) *QUnhandledException {
|
|
var n = NewQUnhandledExceptionFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QUnicodeTables::GraphemeBreakClass
|
|
type QUnicodeTables__GraphemeBreakClass int64
|
|
|
|
const (
|
|
QUnicodeTables__GraphemeBreak_Other = QUnicodeTables__GraphemeBreakClass(0)
|
|
QUnicodeTables__GraphemeBreak_CR = QUnicodeTables__GraphemeBreakClass(1)
|
|
QUnicodeTables__GraphemeBreak_LF = QUnicodeTables__GraphemeBreakClass(2)
|
|
QUnicodeTables__GraphemeBreak_Control = QUnicodeTables__GraphemeBreakClass(3)
|
|
QUnicodeTables__GraphemeBreak_Extend = QUnicodeTables__GraphemeBreakClass(4)
|
|
QUnicodeTables__GraphemeBreak_RegionalIndicator = QUnicodeTables__GraphemeBreakClass(5)
|
|
QUnicodeTables__GraphemeBreak_Prepend = QUnicodeTables__GraphemeBreakClass(6)
|
|
QUnicodeTables__GraphemeBreak_SpacingMark = QUnicodeTables__GraphemeBreakClass(7)
|
|
QUnicodeTables__GraphemeBreak_L = QUnicodeTables__GraphemeBreakClass(8)
|
|
QUnicodeTables__GraphemeBreak_V = QUnicodeTables__GraphemeBreakClass(9)
|
|
QUnicodeTables__GraphemeBreak_T = QUnicodeTables__GraphemeBreakClass(10)
|
|
QUnicodeTables__GraphemeBreak_LV = QUnicodeTables__GraphemeBreakClass(11)
|
|
QUnicodeTables__GraphemeBreak_LVT = QUnicodeTables__GraphemeBreakClass(12)
|
|
)
|
|
|
|
//QUnicodeTables::LineBreakClass
|
|
type QUnicodeTables__LineBreakClass int64
|
|
|
|
const (
|
|
QUnicodeTables__LineBreak_OP = QUnicodeTables__LineBreakClass(0)
|
|
QUnicodeTables__LineBreak_CL = QUnicodeTables__LineBreakClass(1)
|
|
QUnicodeTables__LineBreak_CP = QUnicodeTables__LineBreakClass(2)
|
|
QUnicodeTables__LineBreak_QU = QUnicodeTables__LineBreakClass(3)
|
|
QUnicodeTables__LineBreak_GL = QUnicodeTables__LineBreakClass(4)
|
|
QUnicodeTables__LineBreak_NS = QUnicodeTables__LineBreakClass(5)
|
|
QUnicodeTables__LineBreak_EX = QUnicodeTables__LineBreakClass(6)
|
|
QUnicodeTables__LineBreak_SY = QUnicodeTables__LineBreakClass(7)
|
|
QUnicodeTables__LineBreak_IS = QUnicodeTables__LineBreakClass(8)
|
|
QUnicodeTables__LineBreak_PR = QUnicodeTables__LineBreakClass(9)
|
|
QUnicodeTables__LineBreak_PO = QUnicodeTables__LineBreakClass(10)
|
|
QUnicodeTables__LineBreak_NU = QUnicodeTables__LineBreakClass(11)
|
|
QUnicodeTables__LineBreak_AL = QUnicodeTables__LineBreakClass(12)
|
|
QUnicodeTables__LineBreak_HL = QUnicodeTables__LineBreakClass(13)
|
|
QUnicodeTables__LineBreak_ID = QUnicodeTables__LineBreakClass(14)
|
|
QUnicodeTables__LineBreak_IN = QUnicodeTables__LineBreakClass(15)
|
|
QUnicodeTables__LineBreak_HY = QUnicodeTables__LineBreakClass(16)
|
|
QUnicodeTables__LineBreak_BA = QUnicodeTables__LineBreakClass(17)
|
|
QUnicodeTables__LineBreak_BB = QUnicodeTables__LineBreakClass(18)
|
|
QUnicodeTables__LineBreak_B2 = QUnicodeTables__LineBreakClass(19)
|
|
QUnicodeTables__LineBreak_ZW = QUnicodeTables__LineBreakClass(20)
|
|
QUnicodeTables__LineBreak_CM = QUnicodeTables__LineBreakClass(21)
|
|
QUnicodeTables__LineBreak_WJ = QUnicodeTables__LineBreakClass(22)
|
|
QUnicodeTables__LineBreak_H2 = QUnicodeTables__LineBreakClass(23)
|
|
QUnicodeTables__LineBreak_H3 = QUnicodeTables__LineBreakClass(24)
|
|
QUnicodeTables__LineBreak_JL = QUnicodeTables__LineBreakClass(25)
|
|
QUnicodeTables__LineBreak_JV = QUnicodeTables__LineBreakClass(26)
|
|
QUnicodeTables__LineBreak_JT = QUnicodeTables__LineBreakClass(27)
|
|
QUnicodeTables__LineBreak_RI = QUnicodeTables__LineBreakClass(28)
|
|
QUnicodeTables__LineBreak_CB = QUnicodeTables__LineBreakClass(29)
|
|
QUnicodeTables__LineBreak_SA = QUnicodeTables__LineBreakClass(30)
|
|
QUnicodeTables__LineBreak_SG = QUnicodeTables__LineBreakClass(31)
|
|
QUnicodeTables__LineBreak_SP = QUnicodeTables__LineBreakClass(32)
|
|
QUnicodeTables__LineBreak_CR = QUnicodeTables__LineBreakClass(33)
|
|
QUnicodeTables__LineBreak_LF = QUnicodeTables__LineBreakClass(34)
|
|
QUnicodeTables__LineBreak_BK = QUnicodeTables__LineBreakClass(35)
|
|
)
|
|
|
|
//QUnicodeTables::SentenceBreakClass
|
|
type QUnicodeTables__SentenceBreakClass int64
|
|
|
|
const (
|
|
QUnicodeTables__SentenceBreak_Other = QUnicodeTables__SentenceBreakClass(0)
|
|
QUnicodeTables__SentenceBreak_CR = QUnicodeTables__SentenceBreakClass(1)
|
|
QUnicodeTables__SentenceBreak_LF = QUnicodeTables__SentenceBreakClass(2)
|
|
QUnicodeTables__SentenceBreak_Sep = QUnicodeTables__SentenceBreakClass(3)
|
|
QUnicodeTables__SentenceBreak_Extend = QUnicodeTables__SentenceBreakClass(4)
|
|
QUnicodeTables__SentenceBreak_Sp = QUnicodeTables__SentenceBreakClass(5)
|
|
QUnicodeTables__SentenceBreak_Lower = QUnicodeTables__SentenceBreakClass(6)
|
|
QUnicodeTables__SentenceBreak_Upper = QUnicodeTables__SentenceBreakClass(7)
|
|
QUnicodeTables__SentenceBreak_OLetter = QUnicodeTables__SentenceBreakClass(8)
|
|
QUnicodeTables__SentenceBreak_Numeric = QUnicodeTables__SentenceBreakClass(9)
|
|
QUnicodeTables__SentenceBreak_ATerm = QUnicodeTables__SentenceBreakClass(10)
|
|
QUnicodeTables__SentenceBreak_SContinue = QUnicodeTables__SentenceBreakClass(11)
|
|
QUnicodeTables__SentenceBreak_STerm = QUnicodeTables__SentenceBreakClass(12)
|
|
QUnicodeTables__SentenceBreak_Close = QUnicodeTables__SentenceBreakClass(13)
|
|
)
|
|
|
|
//QUnicodeTables::WordBreakClass
|
|
type QUnicodeTables__WordBreakClass int64
|
|
|
|
const (
|
|
QUnicodeTables__WordBreak_Other = QUnicodeTables__WordBreakClass(0)
|
|
QUnicodeTables__WordBreak_CR = QUnicodeTables__WordBreakClass(1)
|
|
QUnicodeTables__WordBreak_LF = QUnicodeTables__WordBreakClass(2)
|
|
QUnicodeTables__WordBreak_Newline = QUnicodeTables__WordBreakClass(3)
|
|
QUnicodeTables__WordBreak_Extend = QUnicodeTables__WordBreakClass(4)
|
|
QUnicodeTables__WordBreak_RegionalIndicator = QUnicodeTables__WordBreakClass(5)
|
|
QUnicodeTables__WordBreak_Katakana = QUnicodeTables__WordBreakClass(6)
|
|
QUnicodeTables__WordBreak_HebrewLetter = QUnicodeTables__WordBreakClass(7)
|
|
QUnicodeTables__WordBreak_ALetter = QUnicodeTables__WordBreakClass(8)
|
|
QUnicodeTables__WordBreak_SingleQuote = QUnicodeTables__WordBreakClass(9)
|
|
QUnicodeTables__WordBreak_DoubleQuote = QUnicodeTables__WordBreakClass(10)
|
|
QUnicodeTables__WordBreak_MidNumLet = QUnicodeTables__WordBreakClass(11)
|
|
QUnicodeTables__WordBreak_MidLetter = QUnicodeTables__WordBreakClass(12)
|
|
QUnicodeTables__WordBreak_MidNum = QUnicodeTables__WordBreakClass(13)
|
|
QUnicodeTables__WordBreak_Numeric = QUnicodeTables__WordBreakClass(14)
|
|
QUnicodeTables__WordBreak_ExtendNumLet = QUnicodeTables__WordBreakClass(15)
|
|
)
|
|
|
|
type QUnicodeTables struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QUnicodeTables_ITF interface {
|
|
QUnicodeTables_PTR() *QUnicodeTables
|
|
}
|
|
|
|
func (p *QUnicodeTables) QUnicodeTables_PTR() *QUnicodeTables {
|
|
return p
|
|
}
|
|
|
|
func (p *QUnicodeTables) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QUnicodeTables) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQUnicodeTables(ptr QUnicodeTables_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QUnicodeTables_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQUnicodeTablesFromPointer(ptr unsafe.Pointer) *QUnicodeTables {
|
|
var n = new(QUnicodeTables)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQUnicodeTablesFromPointer(ptr unsafe.Pointer) *QUnicodeTables {
|
|
var n = NewQUnicodeTablesFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QUnicodeTools::CharAttributeOption
|
|
type QUnicodeTools__CharAttributeOption int64
|
|
|
|
const (
|
|
QUnicodeTools__GraphemeBreaks = QUnicodeTools__CharAttributeOption(0x01)
|
|
QUnicodeTools__WordBreaks = QUnicodeTools__CharAttributeOption(0x02)
|
|
QUnicodeTools__SentenceBreaks = QUnicodeTools__CharAttributeOption(0x04)
|
|
QUnicodeTools__LineBreaks = QUnicodeTools__CharAttributeOption(0x08)
|
|
QUnicodeTools__WhiteSpaces = QUnicodeTools__CharAttributeOption(0x10)
|
|
QUnicodeTools__DefaultOptionsCompat = QUnicodeTools__CharAttributeOption(QUnicodeTools__GraphemeBreaks | QUnicodeTools__LineBreaks | QUnicodeTools__WhiteSpaces)
|
|
QUnicodeTools__DontClearAttributes = QUnicodeTools__CharAttributeOption(0x1000)
|
|
)
|
|
|
|
type QUnicodeTools struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QUnicodeTools_ITF interface {
|
|
QUnicodeTools_PTR() *QUnicodeTools
|
|
}
|
|
|
|
func (p *QUnicodeTools) QUnicodeTools_PTR() *QUnicodeTools {
|
|
return p
|
|
}
|
|
|
|
func (p *QUnicodeTools) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QUnicodeTools) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQUnicodeTools(ptr QUnicodeTools_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QUnicodeTools_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQUnicodeToolsFromPointer(ptr unsafe.Pointer) *QUnicodeTools {
|
|
var n = new(QUnicodeTools)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQUnicodeToolsFromPointer(ptr unsafe.Pointer) *QUnicodeTools {
|
|
var n = NewQUnicodeToolsFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QUrl::ComponentFormattingOption
|
|
type QUrl__ComponentFormattingOption int64
|
|
|
|
const (
|
|
QUrl__PrettyDecoded = QUrl__ComponentFormattingOption(0x000000)
|
|
QUrl__EncodeSpaces = QUrl__ComponentFormattingOption(0x100000)
|
|
QUrl__EncodeUnicode = QUrl__ComponentFormattingOption(0x200000)
|
|
QUrl__EncodeDelimiters = QUrl__ComponentFormattingOption(0x400000 | 0x800000)
|
|
QUrl__EncodeReserved = QUrl__ComponentFormattingOption(0x1000000)
|
|
QUrl__DecodeReserved = QUrl__ComponentFormattingOption(0x2000000)
|
|
QUrl__FullyEncoded = QUrl__ComponentFormattingOption(QUrl__EncodeSpaces | QUrl__EncodeUnicode | QUrl__EncodeDelimiters | QUrl__EncodeReserved)
|
|
QUrl__FullyDecoded = QUrl__ComponentFormattingOption(QUrl__FullyEncoded | QUrl__DecodeReserved | 0x4000000)
|
|
)
|
|
|
|
//QUrl::ParsingMode
|
|
type QUrl__ParsingMode int64
|
|
|
|
const (
|
|
QUrl__TolerantMode = QUrl__ParsingMode(0)
|
|
QUrl__StrictMode = QUrl__ParsingMode(1)
|
|
QUrl__DecodedMode = QUrl__ParsingMode(2)
|
|
)
|
|
|
|
//QUrl::UrlFormattingOption
|
|
type QUrl__UrlFormattingOption int64
|
|
|
|
const (
|
|
QUrl__None = QUrl__UrlFormattingOption(0x0)
|
|
QUrl__RemoveScheme = QUrl__UrlFormattingOption(0x1)
|
|
QUrl__RemovePassword = QUrl__UrlFormattingOption(0x2)
|
|
QUrl__RemoveUserInfo = QUrl__UrlFormattingOption(QUrl__RemovePassword | 0x4)
|
|
QUrl__RemovePort = QUrl__UrlFormattingOption(0x8)
|
|
QUrl__RemoveAuthority = QUrl__UrlFormattingOption(QUrl__RemoveUserInfo | QUrl__RemovePort | 0x10)
|
|
QUrl__RemovePath = QUrl__UrlFormattingOption(0x20)
|
|
QUrl__RemoveQuery = QUrl__UrlFormattingOption(0x40)
|
|
QUrl__RemoveFragment = QUrl__UrlFormattingOption(0x80)
|
|
QUrl__PreferLocalFile = QUrl__UrlFormattingOption(0x200)
|
|
QUrl__StripTrailingSlash = QUrl__UrlFormattingOption(0x400)
|
|
QUrl__RemoveFilename = QUrl__UrlFormattingOption(0x800)
|
|
QUrl__NormalizePathSegments = QUrl__UrlFormattingOption(0x1000)
|
|
)
|
|
|
|
//QUrl::UserInputResolutionOption
|
|
type QUrl__UserInputResolutionOption int64
|
|
|
|
const (
|
|
QUrl__DefaultResolution = QUrl__UserInputResolutionOption(0)
|
|
QUrl__AssumeLocalFile = QUrl__UserInputResolutionOption(1)
|
|
)
|
|
|
|
type QUrl struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QUrl_ITF interface {
|
|
QUrl_PTR() *QUrl
|
|
}
|
|
|
|
func (p *QUrl) QUrl_PTR() *QUrl {
|
|
return p
|
|
}
|
|
|
|
func (p *QUrl) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QUrl) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQUrl(ptr QUrl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QUrl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQUrlFromPointer(ptr unsafe.Pointer) *QUrl {
|
|
var n = new(QUrl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQUrlFromPointer(ptr unsafe.Pointer) *QUrl {
|
|
var n = NewQUrlFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func QUrl_FromEncoded(input string, parsingMode QUrl__ParsingMode) *QUrl {
|
|
defer qt.Recovering("QUrl::fromEncoded")
|
|
|
|
return NewQUrlFromPointer(C.QUrl_QUrl_FromEncoded(C.CString(input), C.int(parsingMode)))
|
|
}
|
|
|
|
func (ptr *QUrl) FromEncoded(input string, parsingMode QUrl__ParsingMode) *QUrl {
|
|
defer qt.Recovering("QUrl::fromEncoded")
|
|
|
|
return NewQUrlFromPointer(C.QUrl_QUrl_FromEncoded(C.CString(input), C.int(parsingMode)))
|
|
}
|
|
|
|
func NewQUrl() *QUrl {
|
|
defer qt.Recovering("QUrl::QUrl")
|
|
|
|
return newQUrlFromPointer(C.QUrl_NewQUrl())
|
|
}
|
|
|
|
func NewQUrl4(other QUrl_ITF) *QUrl {
|
|
defer qt.Recovering("QUrl::QUrl")
|
|
|
|
return newQUrlFromPointer(C.QUrl_NewQUrl4(PointerFromQUrl(other)))
|
|
}
|
|
|
|
func NewQUrl3(url string, parsingMode QUrl__ParsingMode) *QUrl {
|
|
defer qt.Recovering("QUrl::QUrl")
|
|
|
|
return newQUrlFromPointer(C.QUrl_NewQUrl3(C.CString(url), C.int(parsingMode)))
|
|
}
|
|
|
|
func NewQUrl2(other QUrl_ITF) *QUrl {
|
|
defer qt.Recovering("QUrl::QUrl")
|
|
|
|
return newQUrlFromPointer(C.QUrl_NewQUrl2(PointerFromQUrl(other)))
|
|
}
|
|
|
|
func (ptr *QUrl) Adjusted(options QUrl__UrlFormattingOption) *QUrl {
|
|
defer qt.Recovering("QUrl::adjusted")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQUrlFromPointer(C.QUrl_Adjusted(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QUrl) Authority(options QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrl::authority")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_Authority(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) Clear() {
|
|
defer qt.Recovering("QUrl::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrl) ErrorString() string {
|
|
defer qt.Recovering("QUrl::errorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) FileName(options QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrl::fileName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_FileName(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) Fragment(options QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrl::fragment")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_Fragment(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func QUrl_FromAce(domain string) string {
|
|
defer qt.Recovering("QUrl::fromAce")
|
|
|
|
return C.GoString(C.QUrl_QUrl_FromAce(C.CString(domain)))
|
|
}
|
|
|
|
func (ptr *QUrl) FromAce(domain string) string {
|
|
defer qt.Recovering("QUrl::fromAce")
|
|
|
|
return C.GoString(C.QUrl_QUrl_FromAce(C.CString(domain)))
|
|
}
|
|
|
|
func QUrl_FromLocalFile(localFile string) *QUrl {
|
|
defer qt.Recovering("QUrl::fromLocalFile")
|
|
|
|
return NewQUrlFromPointer(C.QUrl_QUrl_FromLocalFile(C.CString(localFile)))
|
|
}
|
|
|
|
func (ptr *QUrl) FromLocalFile(localFile string) *QUrl {
|
|
defer qt.Recovering("QUrl::fromLocalFile")
|
|
|
|
return NewQUrlFromPointer(C.QUrl_QUrl_FromLocalFile(C.CString(localFile)))
|
|
}
|
|
|
|
func QUrl_FromPercentEncoding(input string) string {
|
|
defer qt.Recovering("QUrl::fromPercentEncoding")
|
|
|
|
return C.GoString(C.QUrl_QUrl_FromPercentEncoding(C.CString(input)))
|
|
}
|
|
|
|
func (ptr *QUrl) FromPercentEncoding(input string) string {
|
|
defer qt.Recovering("QUrl::fromPercentEncoding")
|
|
|
|
return C.GoString(C.QUrl_QUrl_FromPercentEncoding(C.CString(input)))
|
|
}
|
|
|
|
func QUrl_FromUserInput(userInput string) *QUrl {
|
|
defer qt.Recovering("QUrl::fromUserInput")
|
|
|
|
return NewQUrlFromPointer(C.QUrl_QUrl_FromUserInput(C.CString(userInput)))
|
|
}
|
|
|
|
func (ptr *QUrl) FromUserInput(userInput string) *QUrl {
|
|
defer qt.Recovering("QUrl::fromUserInput")
|
|
|
|
return NewQUrlFromPointer(C.QUrl_QUrl_FromUserInput(C.CString(userInput)))
|
|
}
|
|
|
|
func QUrl_FromUserInput2(userInput string, workingDirectory string, options QUrl__UserInputResolutionOption) *QUrl {
|
|
defer qt.Recovering("QUrl::fromUserInput")
|
|
|
|
return NewQUrlFromPointer(C.QUrl_QUrl_FromUserInput2(C.CString(userInput), C.CString(workingDirectory), C.int(options)))
|
|
}
|
|
|
|
func (ptr *QUrl) FromUserInput2(userInput string, workingDirectory string, options QUrl__UserInputResolutionOption) *QUrl {
|
|
defer qt.Recovering("QUrl::fromUserInput")
|
|
|
|
return NewQUrlFromPointer(C.QUrl_QUrl_FromUserInput2(C.CString(userInput), C.CString(workingDirectory), C.int(options)))
|
|
}
|
|
|
|
func (ptr *QUrl) HasFragment() bool {
|
|
defer qt.Recovering("QUrl::hasFragment")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QUrl_HasFragment(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QUrl) HasQuery() bool {
|
|
defer qt.Recovering("QUrl::hasQuery")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QUrl_HasQuery(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QUrl) Host(options QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrl::host")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_Host(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func QUrl_IdnWhitelist() []string {
|
|
defer qt.Recovering("QUrl::idnWhitelist")
|
|
|
|
return strings.Split(C.GoString(C.QUrl_QUrl_IdnWhitelist()), "|")
|
|
}
|
|
|
|
func (ptr *QUrl) IdnWhitelist() []string {
|
|
defer qt.Recovering("QUrl::idnWhitelist")
|
|
|
|
return strings.Split(C.GoString(C.QUrl_QUrl_IdnWhitelist()), "|")
|
|
}
|
|
|
|
func (ptr *QUrl) IsEmpty() bool {
|
|
defer qt.Recovering("QUrl::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QUrl_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QUrl) IsLocalFile() bool {
|
|
defer qt.Recovering("QUrl::isLocalFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QUrl_IsLocalFile(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QUrl) IsParentOf(childUrl QUrl_ITF) bool {
|
|
defer qt.Recovering("QUrl::isParentOf")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QUrl_IsParentOf(ptr.Pointer(), PointerFromQUrl(childUrl)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QUrl) IsRelative() bool {
|
|
defer qt.Recovering("QUrl::isRelative")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QUrl_IsRelative(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QUrl) IsValid() bool {
|
|
defer qt.Recovering("QUrl::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QUrl_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QUrl) Matches(url QUrl_ITF, options QUrl__UrlFormattingOption) bool {
|
|
defer qt.Recovering("QUrl::matches")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QUrl_Matches(ptr.Pointer(), PointerFromQUrl(url), C.int(options)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QUrl) Password(options QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrl::password")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_Password(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) Path(options QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrl::path")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_Path(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) Port(defaultPort int) int {
|
|
defer qt.Recovering("QUrl::port")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QUrl_Port(ptr.Pointer(), C.int(defaultPort)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QUrl) Query(options QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrl::query")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_Query(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) Resolved(relative QUrl_ITF) *QUrl {
|
|
defer qt.Recovering("QUrl::resolved")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQUrlFromPointer(C.QUrl_Resolved(ptr.Pointer(), PointerFromQUrl(relative)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QUrl) Scheme() string {
|
|
defer qt.Recovering("QUrl::scheme")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_Scheme(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) SetAuthority(authority string, mode QUrl__ParsingMode) {
|
|
defer qt.Recovering("QUrl::setAuthority")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_SetAuthority(ptr.Pointer(), C.CString(authority), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrl) SetFragment(fragment string, mode QUrl__ParsingMode) {
|
|
defer qt.Recovering("QUrl::setFragment")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_SetFragment(ptr.Pointer(), C.CString(fragment), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrl) SetHost(host string, mode QUrl__ParsingMode) {
|
|
defer qt.Recovering("QUrl::setHost")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_SetHost(ptr.Pointer(), C.CString(host), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func QUrl_SetIdnWhitelist(list []string) {
|
|
defer qt.Recovering("QUrl::setIdnWhitelist")
|
|
|
|
C.QUrl_QUrl_SetIdnWhitelist(C.CString(strings.Join(list, "|")))
|
|
}
|
|
|
|
func (ptr *QUrl) SetIdnWhitelist(list []string) {
|
|
defer qt.Recovering("QUrl::setIdnWhitelist")
|
|
|
|
C.QUrl_QUrl_SetIdnWhitelist(C.CString(strings.Join(list, "|")))
|
|
}
|
|
|
|
func (ptr *QUrl) SetPassword(password string, mode QUrl__ParsingMode) {
|
|
defer qt.Recovering("QUrl::setPassword")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_SetPassword(ptr.Pointer(), C.CString(password), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrl) SetPath(path string, mode QUrl__ParsingMode) {
|
|
defer qt.Recovering("QUrl::setPath")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_SetPath(ptr.Pointer(), C.CString(path), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrl) SetPort(port int) {
|
|
defer qt.Recovering("QUrl::setPort")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_SetPort(ptr.Pointer(), C.int(port))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrl) SetQuery(query string, mode QUrl__ParsingMode) {
|
|
defer qt.Recovering("QUrl::setQuery")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_SetQuery(ptr.Pointer(), C.CString(query), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrl) SetQuery2(query QUrlQuery_ITF) {
|
|
defer qt.Recovering("QUrl::setQuery")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_SetQuery2(ptr.Pointer(), PointerFromQUrlQuery(query))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrl) SetScheme(scheme string) {
|
|
defer qt.Recovering("QUrl::setScheme")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_SetScheme(ptr.Pointer(), C.CString(scheme))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrl) SetUrl(url string, parsingMode QUrl__ParsingMode) {
|
|
defer qt.Recovering("QUrl::setUrl")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_SetUrl(ptr.Pointer(), C.CString(url), C.int(parsingMode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrl) SetUserInfo(userInfo string, mode QUrl__ParsingMode) {
|
|
defer qt.Recovering("QUrl::setUserInfo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_SetUserInfo(ptr.Pointer(), C.CString(userInfo), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrl) SetUserName(userName string, mode QUrl__ParsingMode) {
|
|
defer qt.Recovering("QUrl::setUserName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_SetUserName(ptr.Pointer(), C.CString(userName), C.int(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrl) Swap(other QUrl_ITF) {
|
|
defer qt.Recovering("QUrl::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_Swap(ptr.Pointer(), PointerFromQUrl(other))
|
|
}
|
|
}
|
|
|
|
func QUrl_ToAce(domain string) string {
|
|
defer qt.Recovering("QUrl::toAce")
|
|
|
|
return C.GoString(C.QUrl_QUrl_ToAce(C.CString(domain)))
|
|
}
|
|
|
|
func (ptr *QUrl) ToAce(domain string) string {
|
|
defer qt.Recovering("QUrl::toAce")
|
|
|
|
return C.GoString(C.QUrl_QUrl_ToAce(C.CString(domain)))
|
|
}
|
|
|
|
func (ptr *QUrl) ToDisplayString(options QUrl__UrlFormattingOption) string {
|
|
defer qt.Recovering("QUrl::toDisplayString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_ToDisplayString(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) ToEncoded(options QUrl__UrlFormattingOption) string {
|
|
defer qt.Recovering("QUrl::toEncoded")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_ToEncoded(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) ToLocalFile() string {
|
|
defer qt.Recovering("QUrl::toLocalFile")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_ToLocalFile(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func QUrl_ToPercentEncoding(input string, exclude string, include string) string {
|
|
defer qt.Recovering("QUrl::toPercentEncoding")
|
|
|
|
return C.GoString(C.QUrl_QUrl_ToPercentEncoding(C.CString(input), C.CString(exclude), C.CString(include)))
|
|
}
|
|
|
|
func (ptr *QUrl) ToPercentEncoding(input string, exclude string, include string) string {
|
|
defer qt.Recovering("QUrl::toPercentEncoding")
|
|
|
|
return C.GoString(C.QUrl_QUrl_ToPercentEncoding(C.CString(input), C.CString(exclude), C.CString(include)))
|
|
}
|
|
|
|
func (ptr *QUrl) ToString(options QUrl__UrlFormattingOption) string {
|
|
defer qt.Recovering("QUrl::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_ToString(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) TopLevelDomain(options QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrl::topLevelDomain")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_TopLevelDomain(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) Url(options QUrl__UrlFormattingOption) string {
|
|
defer qt.Recovering("QUrl::url")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_Url(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) UserInfo(options QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrl::userInfo")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_UserInfo(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) UserName(options QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrl::userName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrl_UserName(ptr.Pointer(), C.int(options)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrl) DestroyQUrl() {
|
|
defer qt.Recovering("QUrl::~QUrl")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrl_DestroyQUrl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QUrlQuery struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QUrlQuery_ITF interface {
|
|
QUrlQuery_PTR() *QUrlQuery
|
|
}
|
|
|
|
func (p *QUrlQuery) QUrlQuery_PTR() *QUrlQuery {
|
|
return p
|
|
}
|
|
|
|
func (p *QUrlQuery) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QUrlQuery) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQUrlQuery(ptr QUrlQuery_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QUrlQuery_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQUrlQueryFromPointer(ptr unsafe.Pointer) *QUrlQuery {
|
|
var n = new(QUrlQuery)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQUrlQueryFromPointer(ptr unsafe.Pointer) *QUrlQuery {
|
|
var n = NewQUrlQueryFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQUrlQuery() *QUrlQuery {
|
|
defer qt.Recovering("QUrlQuery::QUrlQuery")
|
|
|
|
return newQUrlQueryFromPointer(C.QUrlQuery_NewQUrlQuery())
|
|
}
|
|
|
|
func NewQUrlQuery3(queryString string) *QUrlQuery {
|
|
defer qt.Recovering("QUrlQuery::QUrlQuery")
|
|
|
|
return newQUrlQueryFromPointer(C.QUrlQuery_NewQUrlQuery3(C.CString(queryString)))
|
|
}
|
|
|
|
func NewQUrlQuery2(url QUrl_ITF) *QUrlQuery {
|
|
defer qt.Recovering("QUrlQuery::QUrlQuery")
|
|
|
|
return newQUrlQueryFromPointer(C.QUrlQuery_NewQUrlQuery2(PointerFromQUrl(url)))
|
|
}
|
|
|
|
func NewQUrlQuery4(other QUrlQuery_ITF) *QUrlQuery {
|
|
defer qt.Recovering("QUrlQuery::QUrlQuery")
|
|
|
|
return newQUrlQueryFromPointer(C.QUrlQuery_NewQUrlQuery4(PointerFromQUrlQuery(other)))
|
|
}
|
|
|
|
func (ptr *QUrlQuery) AddQueryItem(key string, value string) {
|
|
defer qt.Recovering("QUrlQuery::addQueryItem")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrlQuery_AddQueryItem(ptr.Pointer(), C.CString(key), C.CString(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrlQuery) AllQueryItemValues(key string, encoding QUrl__ComponentFormattingOption) []string {
|
|
defer qt.Recovering("QUrlQuery::allQueryItemValues")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QUrlQuery_AllQueryItemValues(ptr.Pointer(), C.CString(key), C.int(encoding))), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QUrlQuery) Clear() {
|
|
defer qt.Recovering("QUrlQuery::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrlQuery_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrlQuery) HasQueryItem(key string) bool {
|
|
defer qt.Recovering("QUrlQuery::hasQueryItem")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QUrlQuery_HasQueryItem(ptr.Pointer(), C.CString(key)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QUrlQuery) IsEmpty() bool {
|
|
defer qt.Recovering("QUrlQuery::isEmpty")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QUrlQuery_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QUrlQuery) Query(encoding QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrlQuery::query")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrlQuery_Query(ptr.Pointer(), C.int(encoding)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrlQuery) QueryItemValue(key string, encoding QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrlQuery::queryItemValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrlQuery_QueryItemValue(ptr.Pointer(), C.CString(key), C.int(encoding)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrlQuery) RemoveAllQueryItems(key string) {
|
|
defer qt.Recovering("QUrlQuery::removeAllQueryItems")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrlQuery_RemoveAllQueryItems(ptr.Pointer(), C.CString(key))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrlQuery) RemoveQueryItem(key string) {
|
|
defer qt.Recovering("QUrlQuery::removeQueryItem")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrlQuery_RemoveQueryItem(ptr.Pointer(), C.CString(key))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrlQuery) SetQuery(queryString string) {
|
|
defer qt.Recovering("QUrlQuery::setQuery")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrlQuery_SetQuery(ptr.Pointer(), C.CString(queryString))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrlQuery) SetQueryDelimiters(valueDelimiter QChar_ITF, pairDelimiter QChar_ITF) {
|
|
defer qt.Recovering("QUrlQuery::setQueryDelimiters")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrlQuery_SetQueryDelimiters(ptr.Pointer(), PointerFromQChar(valueDelimiter), PointerFromQChar(pairDelimiter))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrlQuery) Swap(other QUrlQuery_ITF) {
|
|
defer qt.Recovering("QUrlQuery::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrlQuery_Swap(ptr.Pointer(), PointerFromQUrlQuery(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QUrlQuery) ToString(encoding QUrl__ComponentFormattingOption) string {
|
|
defer qt.Recovering("QUrlQuery::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUrlQuery_ToString(ptr.Pointer(), C.int(encoding)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUrlQuery) DestroyQUrlQuery() {
|
|
defer qt.Recovering("QUrlQuery::~QUrlQuery")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QUrlQuery_DestroyQUrlQuery(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QUuid::Variant
|
|
type QUuid__Variant int64
|
|
|
|
const (
|
|
QUuid__VarUnknown = QUuid__Variant(-1)
|
|
QUuid__NCS = QUuid__Variant(0)
|
|
QUuid__DCE = QUuid__Variant(2)
|
|
QUuid__Microsoft = QUuid__Variant(6)
|
|
QUuid__Reserved = QUuid__Variant(7)
|
|
)
|
|
|
|
//QUuid::Version
|
|
type QUuid__Version int64
|
|
|
|
const (
|
|
QUuid__VerUnknown = QUuid__Version(-1)
|
|
QUuid__Time = QUuid__Version(1)
|
|
QUuid__EmbeddedPOSIX = QUuid__Version(2)
|
|
QUuid__Md5 = QUuid__Version(3)
|
|
QUuid__Name = QUuid__Version(QUuid__Md5)
|
|
QUuid__Random = QUuid__Version(4)
|
|
QUuid__Sha1 = QUuid__Version(5)
|
|
)
|
|
|
|
type QUuid struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QUuid_ITF interface {
|
|
QUuid_PTR() *QUuid
|
|
}
|
|
|
|
func (p *QUuid) QUuid_PTR() *QUuid {
|
|
return p
|
|
}
|
|
|
|
func (p *QUuid) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QUuid) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQUuid(ptr QUuid_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QUuid_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQUuidFromPointer(ptr unsafe.Pointer) *QUuid {
|
|
var n = new(QUuid)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQUuidFromPointer(ptr unsafe.Pointer) *QUuid {
|
|
var n = NewQUuidFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QUuid) Variant() QUuid__Variant {
|
|
defer qt.Recovering("QUuid::variant")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QUuid__Variant(C.QUuid_Variant(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QUuid) Version() QUuid__Version {
|
|
defer qt.Recovering("QUuid::version")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QUuid__Version(C.QUuid_Version(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func NewQUuid() *QUuid {
|
|
defer qt.Recovering("QUuid::QUuid")
|
|
|
|
return newQUuidFromPointer(C.QUuid_NewQUuid())
|
|
}
|
|
|
|
func NewQUuid5(text string) *QUuid {
|
|
defer qt.Recovering("QUuid::QUuid")
|
|
|
|
return newQUuidFromPointer(C.QUuid_NewQUuid5(C.CString(text)))
|
|
}
|
|
|
|
func NewQUuid3(text string) *QUuid {
|
|
defer qt.Recovering("QUuid::QUuid")
|
|
|
|
return newQUuidFromPointer(C.QUuid_NewQUuid3(C.CString(text)))
|
|
}
|
|
|
|
func (ptr *QUuid) IsNull() bool {
|
|
defer qt.Recovering("QUuid::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QUuid_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QUuid) ToByteArray() string {
|
|
defer qt.Recovering("QUuid::toByteArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUuid_ToByteArray(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUuid) ToRfc4122() string {
|
|
defer qt.Recovering("QUuid::toRfc4122")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUuid_ToRfc4122(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QUuid) ToString() string {
|
|
defer qt.Recovering("QUuid::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QUuid_ToString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type QVarLengthArray struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QVarLengthArray_ITF interface {
|
|
QVarLengthArray_PTR() *QVarLengthArray
|
|
}
|
|
|
|
func (p *QVarLengthArray) QVarLengthArray_PTR() *QVarLengthArray {
|
|
return p
|
|
}
|
|
|
|
func (p *QVarLengthArray) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QVarLengthArray) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQVarLengthArray(ptr QVarLengthArray_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVarLengthArray_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVarLengthArrayFromPointer(ptr unsafe.Pointer) *QVarLengthArray {
|
|
var n = new(QVarLengthArray)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQVarLengthArrayFromPointer(ptr unsafe.Pointer) *QVarLengthArray {
|
|
var n = NewQVarLengthArrayFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QVariant struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QVariant_ITF interface {
|
|
QVariant_PTR() *QVariant
|
|
}
|
|
|
|
func (p *QVariant) QVariant_PTR() *QVariant {
|
|
return p
|
|
}
|
|
|
|
func (p *QVariant) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QVariant) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQVariant(ptr QVariant_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVariant_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVariantFromPointer(ptr unsafe.Pointer) *QVariant {
|
|
var n = new(QVariant)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQVariantFromPointer(ptr unsafe.Pointer) *QVariant {
|
|
var n = NewQVariantFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQVariant20(c QChar_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant20(PointerFromQChar(c)))
|
|
}
|
|
|
|
func NewQVariant18(val QLatin1String_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant18(PointerFromQLatin1String(val)))
|
|
}
|
|
|
|
func NewQVariant11(val bool) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant11(C.int(qt.GoBoolToInt(val))))
|
|
}
|
|
|
|
func NewQVariant16(val QBitArray_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant16(PointerFromQBitArray(val)))
|
|
}
|
|
|
|
func NewQVariant15(val string) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant15(C.CString(val)))
|
|
}
|
|
|
|
func NewQVariant21(val QDate_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant21(PointerFromQDate(val)))
|
|
}
|
|
|
|
func NewQVariant23(val QDateTime_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant23(PointerFromQDateTime(val)))
|
|
}
|
|
|
|
func NewQVariant39(val QEasingCurve_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant39(PointerFromQEasingCurve(val)))
|
|
}
|
|
|
|
func NewQVariant45(val QJsonArray_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant45(PointerFromQJsonArray(val)))
|
|
}
|
|
|
|
func NewQVariant46(val QJsonDocument_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant46(PointerFromQJsonDocument(val)))
|
|
}
|
|
|
|
func NewQVariant44(val QJsonObject_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant44(PointerFromQJsonObject(val)))
|
|
}
|
|
|
|
func NewQVariant43(val QJsonValue_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant43(PointerFromQJsonValue(val)))
|
|
}
|
|
|
|
func NewQVariant31(val QLine_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant31(PointerFromQLine(val)))
|
|
}
|
|
|
|
func NewQVariant32(val QLineF_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant32(PointerFromQLineF(val)))
|
|
}
|
|
|
|
func NewQVariant35(l QLocale_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant35(PointerFromQLocale(l)))
|
|
}
|
|
|
|
func NewQVariant41(val QModelIndex_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant41(PointerFromQModelIndex(val)))
|
|
}
|
|
|
|
func NewQVariant42(val QPersistentModelIndex_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant42(PointerFromQPersistentModelIndex(val)))
|
|
}
|
|
|
|
func NewQVariant29(val QPoint_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant29(PointerFromQPoint(val)))
|
|
}
|
|
|
|
func NewQVariant30(val QPointF_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant30(PointerFromQPointF(val)))
|
|
}
|
|
|
|
func NewQVariant33(val QRect_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant33(PointerFromQRect(val)))
|
|
}
|
|
|
|
func NewQVariant34(val QRectF_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant34(PointerFromQRectF(val)))
|
|
}
|
|
|
|
func NewQVariant36(regExp QRegExp_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant36(PointerFromQRegExp(regExp)))
|
|
}
|
|
|
|
func NewQVariant37(re QRegularExpression_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant37(PointerFromQRegularExpression(re)))
|
|
}
|
|
|
|
func NewQVariant27(val QSize_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant27(PointerFromQSize(val)))
|
|
}
|
|
|
|
func NewQVariant28(val QSizeF_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant28(PointerFromQSizeF(val)))
|
|
}
|
|
|
|
func NewQVariant17(val string) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant17(C.CString(val)))
|
|
}
|
|
|
|
func NewQVariant19(val []string) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant19(C.CString(strings.Join(val, "|"))))
|
|
}
|
|
|
|
func NewQVariant22(val QTime_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant22(PointerFromQTime(val)))
|
|
}
|
|
|
|
func NewQVariant38(val QUrl_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant38(PointerFromQUrl(val)))
|
|
}
|
|
|
|
func NewQVariant40(val QUuid_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant40(PointerFromQUuid(val)))
|
|
}
|
|
|
|
func NewQVariant5(p QVariant_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant5(PointerFromQVariant(p)))
|
|
}
|
|
|
|
func NewQVariant14(val string) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant14(C.CString(val)))
|
|
}
|
|
|
|
func NewQVariant3(typeId int, copy unsafe.Pointer) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant3(C.int(typeId), copy))
|
|
}
|
|
|
|
func NewQVariant7(val int) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant7(C.int(val)))
|
|
}
|
|
|
|
func (ptr *QVariant) ToByteArray() string {
|
|
defer qt.Recovering("QVariant::toByteArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QVariant_ToByteArray(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QVariant) ToDateTime() *QDateTime {
|
|
defer qt.Recovering("QVariant::toDateTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQDateTimeFromPointer(C.QVariant_ToDateTime(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToEasingCurve() *QEasingCurve {
|
|
defer qt.Recovering("QVariant::toEasingCurve")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQEasingCurveFromPointer(C.QVariant_ToEasingCurve(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToLine() *QLine {
|
|
defer qt.Recovering("QVariant::toLine")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLineFromPointer(C.QVariant_ToLine(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToLineF() *QLineF {
|
|
defer qt.Recovering("QVariant::toLineF")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLineFFromPointer(C.QVariant_ToLineF(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToLocale() *QLocale {
|
|
defer qt.Recovering("QVariant::toLocale")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQLocaleFromPointer(C.QVariant_ToLocale(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToPoint() *QPoint {
|
|
defer qt.Recovering("QVariant::toPoint")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFromPointer(C.QVariant_ToPoint(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToPointF() *QPointF {
|
|
defer qt.Recovering("QVariant::toPointF")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPointFFromPointer(C.QVariant_ToPointF(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToRect() *QRect {
|
|
defer qt.Recovering("QVariant::toRect")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFromPointer(C.QVariant_ToRect(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToRectF() *QRectF {
|
|
defer qt.Recovering("QVariant::toRectF")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRectFFromPointer(C.QVariant_ToRectF(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToRegExp() *QRegExp {
|
|
defer qt.Recovering("QVariant::toRegExp")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRegExpFromPointer(C.QVariant_ToRegExp(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToRegularExpression() *QRegularExpression {
|
|
defer qt.Recovering("QVariant::toRegularExpression")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQRegularExpressionFromPointer(C.QVariant_ToRegularExpression(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToSize() *QSize {
|
|
defer qt.Recovering("QVariant::toSize")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFromPointer(C.QVariant_ToSize(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToSizeF() *QSizeF {
|
|
defer qt.Recovering("QVariant::toSizeF")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQSizeFFromPointer(C.QVariant_ToSizeF(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToStringList() []string {
|
|
defer qt.Recovering("QVariant::toStringList")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(C.GoString(C.QVariant_ToStringList(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QVariant) ToUrl() *QUrl {
|
|
defer qt.Recovering("QVariant::toUrl")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQUrlFromPointer(C.QVariant_ToUrl(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) DestroyQVariant() {
|
|
defer qt.Recovering("QVariant::~QVariant")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariant_DestroyQVariant(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func NewQVariant() *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant())
|
|
}
|
|
|
|
func (ptr *QVariant) Clear() {
|
|
defer qt.Recovering("QVariant::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariant_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func NewQVariant6(s QDataStream_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant6(PointerFromQDataStream(s)))
|
|
}
|
|
|
|
func NewQVariant47(other QVariant_ITF) *QVariant {
|
|
defer qt.Recovering("QVariant::QVariant")
|
|
|
|
return newQVariantFromPointer(C.QVariant_NewQVariant47(PointerFromQVariant(other)))
|
|
}
|
|
|
|
func (ptr *QVariant) Convert(targetTypeId int) bool {
|
|
defer qt.Recovering("QVariant::convert")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QVariant_Convert(ptr.Pointer(), C.int(targetTypeId)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVariant) IsNull() bool {
|
|
defer qt.Recovering("QVariant::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QVariant_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVariant) IsValid() bool {
|
|
defer qt.Recovering("QVariant::isValid")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QVariant_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVariant) Swap(other QVariant_ITF) {
|
|
defer qt.Recovering("QVariant::swap")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariant_Swap(ptr.Pointer(), PointerFromQVariant(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariant) ToBitArray() *QBitArray {
|
|
defer qt.Recovering("QVariant::toBitArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQBitArrayFromPointer(C.QVariant_ToBitArray(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToBool() bool {
|
|
defer qt.Recovering("QVariant::toBool")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QVariant_ToBool(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVariant) ToInt(ok bool) int {
|
|
defer qt.Recovering("QVariant::toInt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QVariant_ToInt(ptr.Pointer(), C.int(qt.GoBoolToInt(ok))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVariant) ToJsonArray() *QJsonArray {
|
|
defer qt.Recovering("QVariant::toJsonArray")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonArrayFromPointer(C.QVariant_ToJsonArray(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToJsonDocument() *QJsonDocument {
|
|
defer qt.Recovering("QVariant::toJsonDocument")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonDocumentFromPointer(C.QVariant_ToJsonDocument(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToJsonObject() *QJsonObject {
|
|
defer qt.Recovering("QVariant::toJsonObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonObjectFromPointer(C.QVariant_ToJsonObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToJsonValue() *QJsonValue {
|
|
defer qt.Recovering("QVariant::toJsonValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQJsonValueFromPointer(C.QVariant_ToJsonValue(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToModelIndex() *QModelIndex {
|
|
defer qt.Recovering("QVariant::toModelIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQModelIndexFromPointer(C.QVariant_ToModelIndex(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToPersistentModelIndex() *QPersistentModelIndex {
|
|
defer qt.Recovering("QVariant::toPersistentModelIndex")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQPersistentModelIndexFromPointer(C.QVariant_ToPersistentModelIndex(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariant) ToReal(ok bool) float64 {
|
|
defer qt.Recovering("QVariant::toReal")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QVariant_ToReal(ptr.Pointer(), C.int(qt.GoBoolToInt(ok))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVariant) ToString() string {
|
|
defer qt.Recovering("QVariant::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QVariant_ToString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QVariant) TypeName() string {
|
|
defer qt.Recovering("QVariant::typeName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QVariant_TypeName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func QVariant_TypeToName(typeId int) string {
|
|
defer qt.Recovering("QVariant::typeToName")
|
|
|
|
return C.GoString(C.QVariant_QVariant_TypeToName(C.int(typeId)))
|
|
}
|
|
|
|
func (ptr *QVariant) TypeToName(typeId int) string {
|
|
defer qt.Recovering("QVariant::typeToName")
|
|
|
|
return C.GoString(C.QVariant_QVariant_TypeToName(C.int(typeId)))
|
|
}
|
|
|
|
func (ptr *QVariant) UserType() int {
|
|
defer qt.Recovering("QVariant::userType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QVariant_UserType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QVariantAnimation struct {
|
|
QAbstractAnimation
|
|
}
|
|
|
|
type QVariantAnimation_ITF interface {
|
|
QAbstractAnimation_ITF
|
|
QVariantAnimation_PTR() *QVariantAnimation
|
|
}
|
|
|
|
func (p *QVariantAnimation) QVariantAnimation_PTR() *QVariantAnimation {
|
|
return p
|
|
}
|
|
|
|
func (p *QVariantAnimation) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QAbstractAnimation_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QVariantAnimation) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QAbstractAnimation_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQVariantAnimation(ptr QVariantAnimation_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVariantAnimation_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVariantAnimationFromPointer(ptr unsafe.Pointer) *QVariantAnimation {
|
|
var n = new(QVariantAnimation)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQVariantAnimationFromPointer(ptr unsafe.Pointer) *QVariantAnimation {
|
|
var n = NewQVariantAnimationFromPointer(ptr)
|
|
for len(n.ObjectName()) < len("QVariantAnimation_") {
|
|
n.SetObjectName("QVariantAnimation_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) CurrentValue() *QVariant {
|
|
defer qt.Recovering("QVariantAnimation::currentValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QVariantAnimation_CurrentValue(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVariantAnimation_Duration
|
|
func callbackQVariantAnimation_Duration(ptr unsafe.Pointer, ptrName *C.char) C.int {
|
|
defer qt.Recovering("callback QVariantAnimation::duration")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "duration"); signal != nil {
|
|
return C.int(signal.(func() int)())
|
|
}
|
|
|
|
return C.int(NewQVariantAnimationFromPointer(ptr).DurationDefault())
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectDuration(f func() int) {
|
|
defer qt.Recovering("connect QVariantAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "duration", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectDuration() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) Duration() int {
|
|
defer qt.Recovering("QVariantAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QVariantAnimation_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DurationDefault() int {
|
|
defer qt.Recovering("QVariantAnimation::duration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QVariantAnimation_DurationDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) EasingCurve() *QEasingCurve {
|
|
defer qt.Recovering("QVariantAnimation::easingCurve")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQEasingCurveFromPointer(C.QVariantAnimation_EasingCurve(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) EndValue() *QVariant {
|
|
defer qt.Recovering("QVariantAnimation::endValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QVariantAnimation_EndValue(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) SetDuration(msecs int) {
|
|
defer qt.Recovering("QVariantAnimation::setDuration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_SetDuration(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) SetEasingCurve(easing QEasingCurve_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::setEasingCurve")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_SetEasingCurve(ptr.Pointer(), PointerFromQEasingCurve(easing))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) SetEndValue(value QVariant_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::setEndValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_SetEndValue(ptr.Pointer(), PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) SetStartValue(value QVariant_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::setStartValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_SetStartValue(ptr.Pointer(), PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) StartValue() *QVariant {
|
|
defer qt.Recovering("QVariantAnimation::startValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QVariantAnimation_StartValue(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVariantAnimation(parent QObject_ITF) *QVariantAnimation {
|
|
defer qt.Recovering("QVariantAnimation::QVariantAnimation")
|
|
|
|
return newQVariantAnimationFromPointer(C.QVariantAnimation_NewQVariantAnimation(PointerFromQObject(parent)))
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) KeyValueAt(step float64) *QVariant {
|
|
defer qt.Recovering("QVariantAnimation::keyValueAt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QVariantAnimation_KeyValueAt(ptr.Pointer(), C.double(step)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVariantAnimation_Event
|
|
func callbackQVariantAnimation_Event(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QVariantAnimation::event")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "event"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QEvent) bool)(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQVariantAnimationFromPointer(ptr).EventDefault(NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectEvent(f func(event *QEvent) bool) {
|
|
defer qt.Recovering("connect QVariantAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "event", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectEvent() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) Event(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QVariantAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QVariantAnimation_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) EventDefault(event QEvent_ITF) bool {
|
|
defer qt.Recovering("QVariantAnimation::event")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QVariantAnimation_EventDefault(ptr.Pointer(), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVariantAnimation_Interpolated
|
|
func callbackQVariantAnimation_Interpolated(ptr unsafe.Pointer, ptrName *C.char, from unsafe.Pointer, to unsafe.Pointer, progress C.double) unsafe.Pointer {
|
|
defer qt.Recovering("callback QVariantAnimation::interpolated")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "interpolated"); signal != nil {
|
|
return PointerFromQVariant(signal.(func(*QVariant, *QVariant, float64) *QVariant)(NewQVariantFromPointer(from), NewQVariantFromPointer(to), float64(progress)))
|
|
}
|
|
|
|
return PointerFromQVariant(NewQVariantAnimationFromPointer(ptr).InterpolatedDefault(NewQVariantFromPointer(from), NewQVariantFromPointer(to), float64(progress)))
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectInterpolated(f func(from *QVariant, to *QVariant, progress float64) *QVariant) {
|
|
defer qt.Recovering("connect QVariantAnimation::interpolated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "interpolated", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectInterpolated() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::interpolated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "interpolated")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) Interpolated(from QVariant_ITF, to QVariant_ITF, progress float64) *QVariant {
|
|
defer qt.Recovering("QVariantAnimation::interpolated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QVariantAnimation_Interpolated(ptr.Pointer(), PointerFromQVariant(from), PointerFromQVariant(to), C.double(progress)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) InterpolatedDefault(from QVariant_ITF, to QVariant_ITF, progress float64) *QVariant {
|
|
defer qt.Recovering("QVariantAnimation::interpolated")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQVariantFromPointer(C.QVariantAnimation_InterpolatedDefault(ptr.Pointer(), PointerFromQVariant(from), PointerFromQVariant(to), C.double(progress)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) SetKeyValueAt(step float64, value QVariant_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::setKeyValueAt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_SetKeyValueAt(ptr.Pointer(), C.double(step), PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_UpdateCurrentTime
|
|
func callbackQVariantAnimation_UpdateCurrentTime(ptr unsafe.Pointer, ptrName *C.char, vin C.int) {
|
|
defer qt.Recovering("callback QVariantAnimation::updateCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(vin))
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).UpdateCurrentTimeDefault(int(vin))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectUpdateCurrentTime(f func(vin int)) {
|
|
defer qt.Recovering("connect QVariantAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectUpdateCurrentTime() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) UpdateCurrentTime(vin int) {
|
|
defer qt.Recovering("QVariantAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_UpdateCurrentTime(ptr.Pointer(), C.int(vin))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) UpdateCurrentTimeDefault(vin int) {
|
|
defer qt.Recovering("QVariantAnimation::updateCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(vin))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_UpdateCurrentValue
|
|
func callbackQVariantAnimation_UpdateCurrentValue(ptr unsafe.Pointer, ptrName *C.char, value unsafe.Pointer) {
|
|
defer qt.Recovering("callback QVariantAnimation::updateCurrentValue")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentValue"); signal != nil {
|
|
signal.(func(*QVariant))(NewQVariantFromPointer(value))
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).UpdateCurrentValueDefault(NewQVariantFromPointer(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectUpdateCurrentValue(f func(value *QVariant)) {
|
|
defer qt.Recovering("connect QVariantAnimation::updateCurrentValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateCurrentValue", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectUpdateCurrentValue() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::updateCurrentValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateCurrentValue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) UpdateCurrentValue(value QVariant_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::updateCurrentValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_UpdateCurrentValue(ptr.Pointer(), PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) UpdateCurrentValueDefault(value QVariant_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::updateCurrentValue")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_UpdateCurrentValueDefault(ptr.Pointer(), PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_UpdateState
|
|
func callbackQVariantAnimation_UpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
|
|
defer qt.Recovering("callback QVariantAnimation::updateState")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
|
|
signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
|
|
defer qt.Recovering("connect QVariantAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectUpdateState() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateState")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QVariantAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
|
|
defer qt.Recovering("QVariantAnimation::updateState")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_ValueChanged
|
|
func callbackQVariantAnimation_ValueChanged(ptr unsafe.Pointer, ptrName *C.char, value unsafe.Pointer) {
|
|
defer qt.Recovering("callback QVariantAnimation::valueChanged")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "valueChanged"); signal != nil {
|
|
signal.(func(*QVariant))(NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectValueChanged(f func(value *QVariant)) {
|
|
defer qt.Recovering("connect QVariantAnimation::valueChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_ConnectValueChanged(ptr.Pointer())
|
|
qt.ConnectSignal(ptr.ObjectName(), "valueChanged", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectValueChanged() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::valueChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_DisconnectValueChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.ObjectName(), "valueChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ValueChanged(value QVariant_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::valueChanged")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_ValueChanged(ptr.Pointer(), PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DestroyQVariantAnimation() {
|
|
defer qt.Recovering("QVariantAnimation::~QVariantAnimation")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QVariantAnimation_DestroyQVariantAnimation(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_SetCurrentTime
|
|
func callbackQVariantAnimation_SetCurrentTime(ptr unsafe.Pointer, ptrName *C.char, msecs C.int) {
|
|
defer qt.Recovering("callback QVariantAnimation::setCurrentTime")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setCurrentTime"); signal != nil {
|
|
signal.(func(int))(int(msecs))
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).SetCurrentTimeDefault(int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectSetCurrentTime(f func(msecs int)) {
|
|
defer qt.Recovering("connect QVariantAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setCurrentTime", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectSetCurrentTime() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setCurrentTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) SetCurrentTime(msecs int) {
|
|
defer qt.Recovering("QVariantAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_SetCurrentTime(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) SetCurrentTimeDefault(msecs int) {
|
|
defer qt.Recovering("QVariantAnimation::setCurrentTime")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_SetCurrentTimeDefault(ptr.Pointer(), C.int(msecs))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_Pause
|
|
func callbackQVariantAnimation_Pause(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QVariantAnimation::pause")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "pause"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).PauseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectPause(f func()) {
|
|
defer qt.Recovering("connect QVariantAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "pause", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectPause() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "pause")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) Pause() {
|
|
defer qt.Recovering("QVariantAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_Pause(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) PauseDefault() {
|
|
defer qt.Recovering("QVariantAnimation::pause")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_PauseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_Resume
|
|
func callbackQVariantAnimation_Resume(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QVariantAnimation::resume")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resume"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).ResumeDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectResume(f func()) {
|
|
defer qt.Recovering("connect QVariantAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "resume", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectResume() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "resume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) Resume() {
|
|
defer qt.Recovering("QVariantAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_Resume(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ResumeDefault() {
|
|
defer qt.Recovering("QVariantAnimation::resume")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_ResumeDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_SetPaused
|
|
func callbackQVariantAnimation_SetPaused(ptr unsafe.Pointer, ptrName *C.char, paused C.int) {
|
|
defer qt.Recovering("callback QVariantAnimation::setPaused")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "setPaused"); signal != nil {
|
|
signal.(func(bool))(int(paused) != 0)
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).SetPausedDefault(int(paused) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectSetPaused(f func(paused bool)) {
|
|
defer qt.Recovering("connect QVariantAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "setPaused", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectSetPaused() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "setPaused")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) SetPaused(paused bool) {
|
|
defer qt.Recovering("QVariantAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_SetPaused(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) SetPausedDefault(paused bool) {
|
|
defer qt.Recovering("QVariantAnimation::setPaused")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_SetPausedDefault(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_Start
|
|
func callbackQVariantAnimation_Start(ptr unsafe.Pointer, ptrName *C.char, policy C.int) {
|
|
defer qt.Recovering("callback QVariantAnimation::start")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "start"); signal != nil {
|
|
signal.(func(QAbstractAnimation__DeletionPolicy))(QAbstractAnimation__DeletionPolicy(policy))
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).StartDefault(QAbstractAnimation__DeletionPolicy(policy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectStart(f func(policy QAbstractAnimation__DeletionPolicy)) {
|
|
defer qt.Recovering("connect QVariantAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "start", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectStart() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) Start(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QVariantAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_Start(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) StartDefault(policy QAbstractAnimation__DeletionPolicy) {
|
|
defer qt.Recovering("QVariantAnimation::start")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_StartDefault(ptr.Pointer(), C.int(policy))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_Stop
|
|
func callbackQVariantAnimation_Stop(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QVariantAnimation::stop")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectStop(f func()) {
|
|
defer qt.Recovering("connect QVariantAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "stop", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectStop() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) Stop() {
|
|
defer qt.Recovering("QVariantAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) StopDefault() {
|
|
defer qt.Recovering("QVariantAnimation::stop")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_UpdateDirection
|
|
func callbackQVariantAnimation_UpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
|
|
defer qt.Recovering("callback QVariantAnimation::updateDirection")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
|
|
signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
|
|
defer qt.Recovering("connect QVariantAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectUpdateDirection() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "updateDirection")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) UpdateDirection(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QVariantAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_UpdateDirection(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
|
|
defer qt.Recovering("QVariantAnimation::updateDirection")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_TimerEvent
|
|
func callbackQVariantAnimation_TimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QVariantAnimation::timerEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
|
|
signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectTimerEvent(f func(event *QTimerEvent)) {
|
|
defer qt.Recovering("connect QVariantAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectTimerEvent() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) TimerEvent(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) TimerEventDefault(event QTimerEvent_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::timerEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_ChildEvent
|
|
func callbackQVariantAnimation_ChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QVariantAnimation::childEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
|
|
signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectChildEvent(f func(event *QChildEvent)) {
|
|
defer qt.Recovering("connect QVariantAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectChildEvent() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ChildEvent(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ChildEventDefault(event QChildEvent_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::childEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_ConnectNotify
|
|
func callbackQVariantAnimation_ConnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QVariantAnimation::connectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "connectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).ConnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectConnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QVariantAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "connectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectConnectNotify() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "connectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::connectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_CustomEvent
|
|
func callbackQVariantAnimation_CustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
|
|
defer qt.Recovering("callback QVariantAnimation::customEvent")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
|
|
signal.(func(*QEvent))(NewQEventFromPointer(event))
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectCustomEvent(f func(event *QEvent)) {
|
|
defer qt.Recovering("connect QVariantAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectCustomEvent() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) CustomEvent(event QEvent_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) CustomEventDefault(event QEvent_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::customEvent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_DeleteLater
|
|
func callbackQVariantAnimation_DeleteLater(ptr unsafe.Pointer, ptrName *C.char) {
|
|
defer qt.Recovering("callback QVariantAnimation::deleteLater")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectDeleteLater(f func()) {
|
|
defer qt.Recovering("connect QVariantAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "deleteLater", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectDeleteLater() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "deleteLater")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DeleteLater() {
|
|
defer qt.Recovering("QVariantAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QVariantAnimation_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DeleteLaterDefault() {
|
|
defer qt.Recovering("QVariantAnimation::deleteLater")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectName())
|
|
C.QVariantAnimation_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_DisconnectNotify
|
|
func callbackQVariantAnimation_DisconnectNotify(ptr unsafe.Pointer, ptrName *C.char, sign unsafe.Pointer) {
|
|
defer qt.Recovering("callback QVariantAnimation::disconnectNotify")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "disconnectNotify"); signal != nil {
|
|
signal.(func(*QMetaMethod))(NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQVariantAnimationFromPointer(ptr).DisconnectNotifyDefault(NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
|
|
defer qt.Recovering("connect QVariantAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "disconnectNotify", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectDisconnectNotify() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "disconnectNotify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectNotify(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
|
|
defer qt.Recovering("QVariantAnimation::disconnectNotify")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QVariantAnimation_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQVariantAnimation_EventFilter
|
|
func callbackQVariantAnimation_EventFilter(ptr unsafe.Pointer, ptrName *C.char, watched unsafe.Pointer, event unsafe.Pointer) C.int {
|
|
defer qt.Recovering("callback QVariantAnimation::eventFilter")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "eventFilter"); signal != nil {
|
|
return C.int(qt.GoBoolToInt(signal.(func(*QObject, *QEvent) bool)(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
return C.int(qt.GoBoolToInt(NewQVariantAnimationFromPointer(ptr).EventFilterDefault(NewQObjectFromPointer(watched), NewQEventFromPointer(event))))
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
|
|
defer qt.Recovering("connect QVariantAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "eventFilter", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectEventFilter() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "eventFilter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QVariantAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QVariantAnimation_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) EventFilterDefault(watched QObject_ITF, event QEvent_ITF) bool {
|
|
defer qt.Recovering("QVariantAnimation::eventFilter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QVariantAnimation_EventFilterDefault(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVariantAnimation_MetaObject
|
|
func callbackQVariantAnimation_MetaObject(ptr unsafe.Pointer, ptrName *C.char) unsafe.Pointer {
|
|
defer qt.Recovering("callback QVariantAnimation::metaObject")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "metaObject"); signal != nil {
|
|
return PointerFromQMetaObject(signal.(func() *QMetaObject)())
|
|
}
|
|
|
|
return PointerFromQMetaObject(NewQVariantAnimationFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) ConnectMetaObject(f func() *QMetaObject) {
|
|
defer qt.Recovering("connect QVariantAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectName(), "metaObject", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) DisconnectMetaObject() {
|
|
defer qt.Recovering("disconnect QVariantAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectName(), "metaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) MetaObject() *QMetaObject {
|
|
defer qt.Recovering("QVariantAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QVariantAnimation_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVariantAnimation) MetaObjectDefault() *QMetaObject {
|
|
defer qt.Recovering("QVariantAnimation::metaObject")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQMetaObjectFromPointer(C.QVariantAnimation_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QVector struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QVector_ITF interface {
|
|
QVector_PTR() *QVector
|
|
}
|
|
|
|
func (p *QVector) QVector_PTR() *QVector {
|
|
return p
|
|
}
|
|
|
|
func (p *QVector) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QVector) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQVector(ptr QVector_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVector_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVectorFromPointer(ptr unsafe.Pointer) *QVector {
|
|
var n = new(QVector)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQVectorFromPointer(ptr unsafe.Pointer) *QVector {
|
|
var n = NewQVectorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QVectorIterator struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QVectorIterator_ITF interface {
|
|
QVectorIterator_PTR() *QVectorIterator
|
|
}
|
|
|
|
func (p *QVectorIterator) QVectorIterator_PTR() *QVectorIterator {
|
|
return p
|
|
}
|
|
|
|
func (p *QVectorIterator) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QVectorIterator) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQVectorIterator(ptr QVectorIterator_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVectorIterator_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVectorIteratorFromPointer(ptr unsafe.Pointer) *QVectorIterator {
|
|
var n = new(QVectorIterator)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQVectorIteratorFromPointer(ptr unsafe.Pointer) *QVectorIterator {
|
|
var n = NewQVectorIteratorFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QVersionNumber struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QVersionNumber_ITF interface {
|
|
QVersionNumber_PTR() *QVersionNumber
|
|
}
|
|
|
|
func (p *QVersionNumber) QVersionNumber_PTR() *QVersionNumber {
|
|
return p
|
|
}
|
|
|
|
func (p *QVersionNumber) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QVersionNumber) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQVersionNumber(ptr QVersionNumber_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVersionNumber_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVersionNumberFromPointer(ptr unsafe.Pointer) *QVersionNumber {
|
|
var n = new(QVersionNumber)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQVersionNumberFromPointer(ptr unsafe.Pointer) *QVersionNumber {
|
|
var n = NewQVersionNumberFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func QVersionNumber_Compare(v1 QVersionNumber_ITF, v2 QVersionNumber_ITF) int {
|
|
defer qt.Recovering("QVersionNumber::compare")
|
|
|
|
return int(C.QVersionNumber_QVersionNumber_Compare(PointerFromQVersionNumber(v1), PointerFromQVersionNumber(v2)))
|
|
}
|
|
|
|
func (ptr *QVersionNumber) Compare(v1 QVersionNumber_ITF, v2 QVersionNumber_ITF) int {
|
|
defer qt.Recovering("QVersionNumber::compare")
|
|
|
|
return int(C.QVersionNumber_QVersionNumber_Compare(PointerFromQVersionNumber(v1), PointerFromQVersionNumber(v2)))
|
|
}
|
|
|
|
func (ptr *QVersionNumber) IsPrefixOf(other QVersionNumber_ITF) bool {
|
|
defer qt.Recovering("QVersionNumber::isPrefixOf")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QVersionNumber_IsPrefixOf(ptr.Pointer(), PointerFromQVersionNumber(other)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVersionNumber) ToString() string {
|
|
defer qt.Recovering("QVersionNumber::toString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QVersionNumber_ToString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func NewQVersionNumber() *QVersionNumber {
|
|
defer qt.Recovering("QVersionNumber::QVersionNumber")
|
|
|
|
return newQVersionNumberFromPointer(C.QVersionNumber_NewQVersionNumber())
|
|
}
|
|
|
|
func NewQVersionNumber5(maj int) *QVersionNumber {
|
|
defer qt.Recovering("QVersionNumber::QVersionNumber")
|
|
|
|
return newQVersionNumberFromPointer(C.QVersionNumber_NewQVersionNumber5(C.int(maj)))
|
|
}
|
|
|
|
func NewQVersionNumber6(maj int, min int) *QVersionNumber {
|
|
defer qt.Recovering("QVersionNumber::QVersionNumber")
|
|
|
|
return newQVersionNumberFromPointer(C.QVersionNumber_NewQVersionNumber6(C.int(maj), C.int(min)))
|
|
}
|
|
|
|
func NewQVersionNumber7(maj int, min int, mic int) *QVersionNumber {
|
|
defer qt.Recovering("QVersionNumber::QVersionNumber")
|
|
|
|
return newQVersionNumberFromPointer(C.QVersionNumber_NewQVersionNumber7(C.int(maj), C.int(min), C.int(mic)))
|
|
}
|
|
|
|
func (ptr *QVersionNumber) IsNormalized() bool {
|
|
defer qt.Recovering("QVersionNumber::isNormalized")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QVersionNumber_IsNormalized(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVersionNumber) IsNull() bool {
|
|
defer qt.Recovering("QVersionNumber::isNull")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QVersionNumber_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVersionNumber) MajorVersion() int {
|
|
defer qt.Recovering("QVersionNumber::majorVersion")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QVersionNumber_MajorVersion(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVersionNumber) MicroVersion() int {
|
|
defer qt.Recovering("QVersionNumber::microVersion")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QVersionNumber_MicroVersion(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVersionNumber) MinorVersion() int {
|
|
defer qt.Recovering("QVersionNumber::minorVersion")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QVersionNumber_MinorVersion(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVersionNumber) SegmentAt(index int) int {
|
|
defer qt.Recovering("QVersionNumber::segmentAt")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QVersionNumber_SegmentAt(ptr.Pointer(), C.int(index)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVersionNumber) SegmentCount() int {
|
|
defer qt.Recovering("QVersionNumber::segmentCount")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QVersionNumber_SegmentCount(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QWaitCondition struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QWaitCondition_ITF interface {
|
|
QWaitCondition_PTR() *QWaitCondition
|
|
}
|
|
|
|
func (p *QWaitCondition) QWaitCondition_PTR() *QWaitCondition {
|
|
return p
|
|
}
|
|
|
|
func (p *QWaitCondition) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QWaitCondition) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQWaitCondition(ptr QWaitCondition_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWaitCondition_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWaitConditionFromPointer(ptr unsafe.Pointer) *QWaitCondition {
|
|
var n = new(QWaitCondition)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQWaitConditionFromPointer(ptr unsafe.Pointer) *QWaitCondition {
|
|
var n = NewQWaitConditionFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQWaitCondition() *QWaitCondition {
|
|
defer qt.Recovering("QWaitCondition::QWaitCondition")
|
|
|
|
return newQWaitConditionFromPointer(C.QWaitCondition_NewQWaitCondition())
|
|
}
|
|
|
|
func (ptr *QWaitCondition) WakeAll() {
|
|
defer qt.Recovering("QWaitCondition::wakeAll")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QWaitCondition_WakeAll(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QWaitCondition) WakeOne() {
|
|
defer qt.Recovering("QWaitCondition::wakeOne")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QWaitCondition_WakeOne(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QWaitCondition) DestroyQWaitCondition() {
|
|
defer qt.Recovering("QWaitCondition::~QWaitCondition")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QWaitCondition_DestroyQWaitCondition(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QWeakPointer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QWeakPointer_ITF interface {
|
|
QWeakPointer_PTR() *QWeakPointer
|
|
}
|
|
|
|
func (p *QWeakPointer) QWeakPointer_PTR() *QWeakPointer {
|
|
return p
|
|
}
|
|
|
|
func (p *QWeakPointer) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QWeakPointer) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQWeakPointer(ptr QWeakPointer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWeakPointer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWeakPointerFromPointer(ptr unsafe.Pointer) *QWeakPointer {
|
|
var n = new(QWeakPointer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQWeakPointerFromPointer(ptr unsafe.Pointer) *QWeakPointer {
|
|
var n = NewQWeakPointerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QWinEventNotifier struct {
|
|
QObject
|
|
}
|
|
|
|
type QWinEventNotifier_ITF interface {
|
|
QObject_ITF
|
|
QWinEventNotifier_PTR() *QWinEventNotifier
|
|
}
|
|
|
|
func (p *QWinEventNotifier) QWinEventNotifier_PTR() *QWinEventNotifier {
|
|
return p
|
|
}
|
|
|
|
func (p *QWinEventNotifier) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QWinEventNotifier) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QObject_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinEventNotifier(ptr QWinEventNotifier_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinEventNotifier_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinEventNotifierFromPointer(ptr unsafe.Pointer) *QWinEventNotifier {
|
|
var n = new(QWinEventNotifier)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQWinEventNotifierFromPointer(ptr unsafe.Pointer) *QWinEventNotifier {
|
|
var n = NewQWinEventNotifierFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
type QWriteLocker struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QWriteLocker_ITF interface {
|
|
QWriteLocker_PTR() *QWriteLocker
|
|
}
|
|
|
|
func (p *QWriteLocker) QWriteLocker_PTR() *QWriteLocker {
|
|
return p
|
|
}
|
|
|
|
func (p *QWriteLocker) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QWriteLocker) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQWriteLocker(ptr QWriteLocker_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWriteLocker_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWriteLockerFromPointer(ptr unsafe.Pointer) *QWriteLocker {
|
|
var n = new(QWriteLocker)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQWriteLockerFromPointer(ptr unsafe.Pointer) *QWriteLocker {
|
|
var n = NewQWriteLockerFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQWriteLocker(lock QReadWriteLock_ITF) *QWriteLocker {
|
|
defer qt.Recovering("QWriteLocker::QWriteLocker")
|
|
|
|
return newQWriteLockerFromPointer(C.QWriteLocker_NewQWriteLocker(PointerFromQReadWriteLock(lock)))
|
|
}
|
|
|
|
func (ptr *QWriteLocker) ReadWriteLock() *QReadWriteLock {
|
|
defer qt.Recovering("QWriteLocker::readWriteLock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQReadWriteLockFromPointer(C.QWriteLocker_ReadWriteLock(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWriteLocker) Relock() {
|
|
defer qt.Recovering("QWriteLocker::relock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QWriteLocker_Relock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QWriteLocker) Unlock() {
|
|
defer qt.Recovering("QWriteLocker::unlock")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QWriteLocker_Unlock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QWriteLocker) DestroyQWriteLocker() {
|
|
defer qt.Recovering("QWriteLocker::~QWriteLocker")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QWriteLocker_DestroyQWriteLocker(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QXmlStreamAttribute struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QXmlStreamAttribute_ITF interface {
|
|
QXmlStreamAttribute_PTR() *QXmlStreamAttribute
|
|
}
|
|
|
|
func (p *QXmlStreamAttribute) QXmlStreamAttribute_PTR() *QXmlStreamAttribute {
|
|
return p
|
|
}
|
|
|
|
func (p *QXmlStreamAttribute) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QXmlStreamAttribute) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQXmlStreamAttribute(ptr QXmlStreamAttribute_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QXmlStreamAttribute_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQXmlStreamAttributeFromPointer(ptr unsafe.Pointer) *QXmlStreamAttribute {
|
|
var n = new(QXmlStreamAttribute)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQXmlStreamAttributeFromPointer(ptr unsafe.Pointer) *QXmlStreamAttribute {
|
|
var n = NewQXmlStreamAttributeFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQXmlStreamAttribute() *QXmlStreamAttribute {
|
|
defer qt.Recovering("QXmlStreamAttribute::QXmlStreamAttribute")
|
|
|
|
return newQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute())
|
|
}
|
|
|
|
func NewQXmlStreamAttribute5(other QXmlStreamAttribute_ITF) *QXmlStreamAttribute {
|
|
defer qt.Recovering("QXmlStreamAttribute::QXmlStreamAttribute")
|
|
|
|
return newQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute5(PointerFromQXmlStreamAttribute(other)))
|
|
}
|
|
|
|
func NewQXmlStreamAttribute3(namespaceUri string, name string, value string) *QXmlStreamAttribute {
|
|
defer qt.Recovering("QXmlStreamAttribute::QXmlStreamAttribute")
|
|
|
|
return newQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute3(C.CString(namespaceUri), C.CString(name), C.CString(value)))
|
|
}
|
|
|
|
func NewQXmlStreamAttribute2(qualifiedName string, value string) *QXmlStreamAttribute {
|
|
defer qt.Recovering("QXmlStreamAttribute::QXmlStreamAttribute")
|
|
|
|
return newQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute2(C.CString(qualifiedName), C.CString(value)))
|
|
}
|
|
|
|
func NewQXmlStreamAttribute4(other QXmlStreamAttribute_ITF) *QXmlStreamAttribute {
|
|
defer qt.Recovering("QXmlStreamAttribute::QXmlStreamAttribute")
|
|
|
|
return newQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute4(PointerFromQXmlStreamAttribute(other)))
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttribute) IsDefault() bool {
|
|
defer qt.Recovering("QXmlStreamAttribute::isDefault")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamAttribute_IsDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttribute) Name() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamAttribute::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamAttribute_Name(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttribute) NamespaceUri() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamAttribute::namespaceUri")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamAttribute_NamespaceUri(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttribute) Prefix() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamAttribute::prefix")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamAttribute_Prefix(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttribute) QualifiedName() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamAttribute::qualifiedName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamAttribute_QualifiedName(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttribute) Value() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamAttribute::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamAttribute_Value(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttribute) DestroyQXmlStreamAttribute() {
|
|
defer qt.Recovering("QXmlStreamAttribute::~QXmlStreamAttribute")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamAttribute_DestroyQXmlStreamAttribute(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QXmlStreamAttributes struct {
|
|
QVector
|
|
}
|
|
|
|
type QXmlStreamAttributes_ITF interface {
|
|
QVector_ITF
|
|
QXmlStreamAttributes_PTR() *QXmlStreamAttributes
|
|
}
|
|
|
|
func (p *QXmlStreamAttributes) QXmlStreamAttributes_PTR() *QXmlStreamAttributes {
|
|
return p
|
|
}
|
|
|
|
func (p *QXmlStreamAttributes) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.QVector_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QXmlStreamAttributes) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.QVector_PTR().SetPointer(ptr)
|
|
}
|
|
}
|
|
|
|
func PointerFromQXmlStreamAttributes(ptr QXmlStreamAttributes_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QXmlStreamAttributes_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQXmlStreamAttributesFromPointer(ptr unsafe.Pointer) *QXmlStreamAttributes {
|
|
var n = new(QXmlStreamAttributes)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQXmlStreamAttributesFromPointer(ptr unsafe.Pointer) *QXmlStreamAttributes {
|
|
var n = NewQXmlStreamAttributesFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQXmlStreamAttributes() *QXmlStreamAttributes {
|
|
defer qt.Recovering("QXmlStreamAttributes::QXmlStreamAttributes")
|
|
|
|
return newQXmlStreamAttributesFromPointer(C.QXmlStreamAttributes_NewQXmlStreamAttributes())
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttributes) Append(namespaceUri string, name string, value string) {
|
|
defer qt.Recovering("QXmlStreamAttributes::append")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamAttributes_Append(ptr.Pointer(), C.CString(namespaceUri), C.CString(name), C.CString(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttributes) Append2(qualifiedName string, value string) {
|
|
defer qt.Recovering("QXmlStreamAttributes::append")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamAttributes_Append2(ptr.Pointer(), C.CString(qualifiedName), C.CString(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttributes) HasAttribute2(qualifiedName QLatin1String_ITF) bool {
|
|
defer qt.Recovering("QXmlStreamAttributes::hasAttribute")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamAttributes_HasAttribute2(ptr.Pointer(), PointerFromQLatin1String(qualifiedName)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttributes) HasAttribute3(namespaceUri string, name string) bool {
|
|
defer qt.Recovering("QXmlStreamAttributes::hasAttribute")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamAttributes_HasAttribute3(ptr.Pointer(), C.CString(namespaceUri), C.CString(name)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttributes) HasAttribute(qualifiedName string) bool {
|
|
defer qt.Recovering("QXmlStreamAttributes::hasAttribute")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamAttributes_HasAttribute(ptr.Pointer(), C.CString(qualifiedName)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttributes) Value3(namespaceUri QLatin1String_ITF, name QLatin1String_ITF) *QStringRef {
|
|
defer qt.Recovering("QXmlStreamAttributes::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamAttributes_Value3(ptr.Pointer(), PointerFromQLatin1String(namespaceUri), PointerFromQLatin1String(name)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttributes) Value5(qualifiedName QLatin1String_ITF) *QStringRef {
|
|
defer qt.Recovering("QXmlStreamAttributes::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamAttributes_Value5(ptr.Pointer(), PointerFromQLatin1String(qualifiedName)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttributes) Value2(namespaceUri string, name QLatin1String_ITF) *QStringRef {
|
|
defer qt.Recovering("QXmlStreamAttributes::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamAttributes_Value2(ptr.Pointer(), C.CString(namespaceUri), PointerFromQLatin1String(name)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttributes) Value(namespaceUri string, name string) *QStringRef {
|
|
defer qt.Recovering("QXmlStreamAttributes::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamAttributes_Value(ptr.Pointer(), C.CString(namespaceUri), C.CString(name)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamAttributes) Value4(qualifiedName string) *QStringRef {
|
|
defer qt.Recovering("QXmlStreamAttributes::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamAttributes_Value4(ptr.Pointer(), C.CString(qualifiedName)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QXmlStreamEntityDeclaration struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QXmlStreamEntityDeclaration_ITF interface {
|
|
QXmlStreamEntityDeclaration_PTR() *QXmlStreamEntityDeclaration
|
|
}
|
|
|
|
func (p *QXmlStreamEntityDeclaration) QXmlStreamEntityDeclaration_PTR() *QXmlStreamEntityDeclaration {
|
|
return p
|
|
}
|
|
|
|
func (p *QXmlStreamEntityDeclaration) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QXmlStreamEntityDeclaration) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQXmlStreamEntityDeclaration(ptr QXmlStreamEntityDeclaration_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QXmlStreamEntityDeclaration_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQXmlStreamEntityDeclarationFromPointer(ptr unsafe.Pointer) *QXmlStreamEntityDeclaration {
|
|
var n = new(QXmlStreamEntityDeclaration)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQXmlStreamEntityDeclarationFromPointer(ptr unsafe.Pointer) *QXmlStreamEntityDeclaration {
|
|
var n = NewQXmlStreamEntityDeclarationFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQXmlStreamEntityDeclaration() *QXmlStreamEntityDeclaration {
|
|
defer qt.Recovering("QXmlStreamEntityDeclaration::QXmlStreamEntityDeclaration")
|
|
|
|
return newQXmlStreamEntityDeclarationFromPointer(C.QXmlStreamEntityDeclaration_NewQXmlStreamEntityDeclaration())
|
|
}
|
|
|
|
func NewQXmlStreamEntityDeclaration2(other QXmlStreamEntityDeclaration_ITF) *QXmlStreamEntityDeclaration {
|
|
defer qt.Recovering("QXmlStreamEntityDeclaration::QXmlStreamEntityDeclaration")
|
|
|
|
return newQXmlStreamEntityDeclarationFromPointer(C.QXmlStreamEntityDeclaration_NewQXmlStreamEntityDeclaration2(PointerFromQXmlStreamEntityDeclaration(other)))
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityDeclaration) Name() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamEntityDeclaration::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_Name(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityDeclaration) NotationName() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamEntityDeclaration::notationName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_NotationName(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityDeclaration) PublicId() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamEntityDeclaration::publicId")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_PublicId(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityDeclaration) SystemId() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamEntityDeclaration::systemId")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_SystemId(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityDeclaration) Value() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamEntityDeclaration::value")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_Value(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityDeclaration) DestroyQXmlStreamEntityDeclaration() {
|
|
defer qt.Recovering("QXmlStreamEntityDeclaration::~QXmlStreamEntityDeclaration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamEntityDeclaration_DestroyQXmlStreamEntityDeclaration(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QXmlStreamEntityResolver struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QXmlStreamEntityResolver_ITF interface {
|
|
QXmlStreamEntityResolver_PTR() *QXmlStreamEntityResolver
|
|
}
|
|
|
|
func (p *QXmlStreamEntityResolver) QXmlStreamEntityResolver_PTR() *QXmlStreamEntityResolver {
|
|
return p
|
|
}
|
|
|
|
func (p *QXmlStreamEntityResolver) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QXmlStreamEntityResolver) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQXmlStreamEntityResolver(ptr QXmlStreamEntityResolver_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QXmlStreamEntityResolver_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQXmlStreamEntityResolverFromPointer(ptr unsafe.Pointer) *QXmlStreamEntityResolver {
|
|
var n = new(QXmlStreamEntityResolver)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQXmlStreamEntityResolverFromPointer(ptr unsafe.Pointer) *QXmlStreamEntityResolver {
|
|
var n = NewQXmlStreamEntityResolverFromPointer(ptr)
|
|
for len(n.ObjectNameAbs()) < len("QXmlStreamEntityResolver_") {
|
|
n.SetObjectNameAbs("QXmlStreamEntityResolver_" + qt.Identifier())
|
|
}
|
|
return n
|
|
}
|
|
|
|
//export callbackQXmlStreamEntityResolver_ResolveUndeclaredEntity
|
|
func callbackQXmlStreamEntityResolver_ResolveUndeclaredEntity(ptr unsafe.Pointer, ptrName *C.char, name *C.char) *C.char {
|
|
defer qt.Recovering("callback QXmlStreamEntityResolver::resolveUndeclaredEntity")
|
|
|
|
if signal := qt.GetSignal(C.GoString(ptrName), "resolveUndeclaredEntity"); signal != nil {
|
|
return C.CString(signal.(func(string) string)(C.GoString(name)))
|
|
}
|
|
|
|
return C.CString(NewQXmlStreamEntityResolverFromPointer(ptr).ResolveUndeclaredEntityDefault(C.GoString(name)))
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityResolver) ConnectResolveUndeclaredEntity(f func(name string) string) {
|
|
defer qt.Recovering("connect QXmlStreamEntityResolver::resolveUndeclaredEntity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.ConnectSignal(ptr.ObjectNameAbs(), "resolveUndeclaredEntity", f)
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityResolver) DisconnectResolveUndeclaredEntity() {
|
|
defer qt.Recovering("disconnect QXmlStreamEntityResolver::resolveUndeclaredEntity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.ObjectNameAbs(), "resolveUndeclaredEntity")
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityResolver) ResolveUndeclaredEntity(name string) string {
|
|
defer qt.Recovering("QXmlStreamEntityResolver::resolveUndeclaredEntity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QXmlStreamEntityResolver_ResolveUndeclaredEntity(ptr.Pointer(), C.CString(name)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityResolver) ResolveUndeclaredEntityDefault(name string) string {
|
|
defer qt.Recovering("QXmlStreamEntityResolver::resolveUndeclaredEntity")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QXmlStreamEntityResolver_ResolveUndeclaredEntityDefault(ptr.Pointer(), C.CString(name)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityResolver) DestroyQXmlStreamEntityResolver() {
|
|
defer qt.Recovering("QXmlStreamEntityResolver::~QXmlStreamEntityResolver")
|
|
|
|
if ptr.Pointer() != nil {
|
|
qt.DisconnectAllSignals(ptr.ObjectNameAbs())
|
|
C.QXmlStreamEntityResolver_DestroyQXmlStreamEntityResolver(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityResolver) ObjectNameAbs() string {
|
|
defer qt.Recovering("QXmlStreamEntityResolver::objectNameAbs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QXmlStreamEntityResolver_ObjectNameAbs(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QXmlStreamEntityResolver) SetObjectNameAbs(name string) {
|
|
defer qt.Recovering("QXmlStreamEntityResolver::setObjectNameAbs")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamEntityResolver_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
|
|
}
|
|
}
|
|
|
|
type QXmlStreamNamespaceDeclaration struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QXmlStreamNamespaceDeclaration_ITF interface {
|
|
QXmlStreamNamespaceDeclaration_PTR() *QXmlStreamNamespaceDeclaration
|
|
}
|
|
|
|
func (p *QXmlStreamNamespaceDeclaration) QXmlStreamNamespaceDeclaration_PTR() *QXmlStreamNamespaceDeclaration {
|
|
return p
|
|
}
|
|
|
|
func (p *QXmlStreamNamespaceDeclaration) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QXmlStreamNamespaceDeclaration) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQXmlStreamNamespaceDeclaration(ptr QXmlStreamNamespaceDeclaration_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QXmlStreamNamespaceDeclaration_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQXmlStreamNamespaceDeclarationFromPointer(ptr unsafe.Pointer) *QXmlStreamNamespaceDeclaration {
|
|
var n = new(QXmlStreamNamespaceDeclaration)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQXmlStreamNamespaceDeclarationFromPointer(ptr unsafe.Pointer) *QXmlStreamNamespaceDeclaration {
|
|
var n = NewQXmlStreamNamespaceDeclarationFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQXmlStreamNamespaceDeclaration() *QXmlStreamNamespaceDeclaration {
|
|
defer qt.Recovering("QXmlStreamNamespaceDeclaration::QXmlStreamNamespaceDeclaration")
|
|
|
|
return newQXmlStreamNamespaceDeclarationFromPointer(C.QXmlStreamNamespaceDeclaration_NewQXmlStreamNamespaceDeclaration())
|
|
}
|
|
|
|
func NewQXmlStreamNamespaceDeclaration3(prefix string, namespaceUri string) *QXmlStreamNamespaceDeclaration {
|
|
defer qt.Recovering("QXmlStreamNamespaceDeclaration::QXmlStreamNamespaceDeclaration")
|
|
|
|
return newQXmlStreamNamespaceDeclarationFromPointer(C.QXmlStreamNamespaceDeclaration_NewQXmlStreamNamespaceDeclaration3(C.CString(prefix), C.CString(namespaceUri)))
|
|
}
|
|
|
|
func NewQXmlStreamNamespaceDeclaration2(other QXmlStreamNamespaceDeclaration_ITF) *QXmlStreamNamespaceDeclaration {
|
|
defer qt.Recovering("QXmlStreamNamespaceDeclaration::QXmlStreamNamespaceDeclaration")
|
|
|
|
return newQXmlStreamNamespaceDeclarationFromPointer(C.QXmlStreamNamespaceDeclaration_NewQXmlStreamNamespaceDeclaration2(PointerFromQXmlStreamNamespaceDeclaration(other)))
|
|
}
|
|
|
|
func (ptr *QXmlStreamNamespaceDeclaration) NamespaceUri() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamNamespaceDeclaration::namespaceUri")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamNamespaceDeclaration_NamespaceUri(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamNamespaceDeclaration) Prefix() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamNamespaceDeclaration::prefix")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamNamespaceDeclaration_Prefix(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamNamespaceDeclaration) DestroyQXmlStreamNamespaceDeclaration() {
|
|
defer qt.Recovering("QXmlStreamNamespaceDeclaration::~QXmlStreamNamespaceDeclaration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamNamespaceDeclaration_DestroyQXmlStreamNamespaceDeclaration(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QXmlStreamNotationDeclaration struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QXmlStreamNotationDeclaration_ITF interface {
|
|
QXmlStreamNotationDeclaration_PTR() *QXmlStreamNotationDeclaration
|
|
}
|
|
|
|
func (p *QXmlStreamNotationDeclaration) QXmlStreamNotationDeclaration_PTR() *QXmlStreamNotationDeclaration {
|
|
return p
|
|
}
|
|
|
|
func (p *QXmlStreamNotationDeclaration) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QXmlStreamNotationDeclaration) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQXmlStreamNotationDeclaration(ptr QXmlStreamNotationDeclaration_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QXmlStreamNotationDeclaration_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQXmlStreamNotationDeclarationFromPointer(ptr unsafe.Pointer) *QXmlStreamNotationDeclaration {
|
|
var n = new(QXmlStreamNotationDeclaration)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQXmlStreamNotationDeclarationFromPointer(ptr unsafe.Pointer) *QXmlStreamNotationDeclaration {
|
|
var n = NewQXmlStreamNotationDeclarationFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func NewQXmlStreamNotationDeclaration() *QXmlStreamNotationDeclaration {
|
|
defer qt.Recovering("QXmlStreamNotationDeclaration::QXmlStreamNotationDeclaration")
|
|
|
|
return newQXmlStreamNotationDeclarationFromPointer(C.QXmlStreamNotationDeclaration_NewQXmlStreamNotationDeclaration())
|
|
}
|
|
|
|
func NewQXmlStreamNotationDeclaration2(other QXmlStreamNotationDeclaration_ITF) *QXmlStreamNotationDeclaration {
|
|
defer qt.Recovering("QXmlStreamNotationDeclaration::QXmlStreamNotationDeclaration")
|
|
|
|
return newQXmlStreamNotationDeclarationFromPointer(C.QXmlStreamNotationDeclaration_NewQXmlStreamNotationDeclaration2(PointerFromQXmlStreamNotationDeclaration(other)))
|
|
}
|
|
|
|
func (ptr *QXmlStreamNotationDeclaration) Name() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamNotationDeclaration::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamNotationDeclaration_Name(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamNotationDeclaration) PublicId() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamNotationDeclaration::publicId")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamNotationDeclaration_PublicId(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamNotationDeclaration) SystemId() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamNotationDeclaration::systemId")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamNotationDeclaration_SystemId(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamNotationDeclaration) DestroyQXmlStreamNotationDeclaration() {
|
|
defer qt.Recovering("QXmlStreamNotationDeclaration::~QXmlStreamNotationDeclaration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamNotationDeclaration_DestroyQXmlStreamNotationDeclaration(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//QXmlStreamReader::Error
|
|
type QXmlStreamReader__Error int64
|
|
|
|
const (
|
|
QXmlStreamReader__NoError = QXmlStreamReader__Error(0)
|
|
QXmlStreamReader__UnexpectedElementError = QXmlStreamReader__Error(1)
|
|
QXmlStreamReader__CustomError = QXmlStreamReader__Error(2)
|
|
QXmlStreamReader__NotWellFormedError = QXmlStreamReader__Error(3)
|
|
QXmlStreamReader__PrematureEndOfDocumentError = QXmlStreamReader__Error(4)
|
|
)
|
|
|
|
//QXmlStreamReader::ReadElementTextBehaviour
|
|
type QXmlStreamReader__ReadElementTextBehaviour int64
|
|
|
|
const (
|
|
QXmlStreamReader__ErrorOnUnexpectedElement = QXmlStreamReader__ReadElementTextBehaviour(0)
|
|
QXmlStreamReader__IncludeChildElements = QXmlStreamReader__ReadElementTextBehaviour(1)
|
|
QXmlStreamReader__SkipChildElements = QXmlStreamReader__ReadElementTextBehaviour(2)
|
|
)
|
|
|
|
//QXmlStreamReader::TokenType
|
|
type QXmlStreamReader__TokenType int64
|
|
|
|
const (
|
|
QXmlStreamReader__NoToken = QXmlStreamReader__TokenType(0)
|
|
QXmlStreamReader__Invalid = QXmlStreamReader__TokenType(1)
|
|
QXmlStreamReader__StartDocument = QXmlStreamReader__TokenType(2)
|
|
QXmlStreamReader__EndDocument = QXmlStreamReader__TokenType(3)
|
|
QXmlStreamReader__StartElement = QXmlStreamReader__TokenType(4)
|
|
QXmlStreamReader__EndElement = QXmlStreamReader__TokenType(5)
|
|
QXmlStreamReader__Characters = QXmlStreamReader__TokenType(6)
|
|
QXmlStreamReader__Comment = QXmlStreamReader__TokenType(7)
|
|
QXmlStreamReader__DTD = QXmlStreamReader__TokenType(8)
|
|
QXmlStreamReader__EntityReference = QXmlStreamReader__TokenType(9)
|
|
QXmlStreamReader__ProcessingInstruction = QXmlStreamReader__TokenType(10)
|
|
)
|
|
|
|
type QXmlStreamReader struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QXmlStreamReader_ITF interface {
|
|
QXmlStreamReader_PTR() *QXmlStreamReader
|
|
}
|
|
|
|
func (p *QXmlStreamReader) QXmlStreamReader_PTR() *QXmlStreamReader {
|
|
return p
|
|
}
|
|
|
|
func (p *QXmlStreamReader) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QXmlStreamReader) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQXmlStreamReader(ptr QXmlStreamReader_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QXmlStreamReader_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQXmlStreamReaderFromPointer(ptr unsafe.Pointer) *QXmlStreamReader {
|
|
var n = new(QXmlStreamReader)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQXmlStreamReaderFromPointer(ptr unsafe.Pointer) *QXmlStreamReader {
|
|
var n = NewQXmlStreamReaderFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) NamespaceProcessing() bool {
|
|
defer qt.Recovering("QXmlStreamReader::namespaceProcessing")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_NamespaceProcessing(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) SetNamespaceProcessing(vbo bool) {
|
|
defer qt.Recovering("QXmlStreamReader::setNamespaceProcessing")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamReader_SetNamespaceProcessing(ptr.Pointer(), C.int(qt.GoBoolToInt(vbo)))
|
|
}
|
|
}
|
|
|
|
func NewQXmlStreamReader() *QXmlStreamReader {
|
|
defer qt.Recovering("QXmlStreamReader::QXmlStreamReader")
|
|
|
|
return newQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader())
|
|
}
|
|
|
|
func NewQXmlStreamReader2(device QIODevice_ITF) *QXmlStreamReader {
|
|
defer qt.Recovering("QXmlStreamReader::QXmlStreamReader")
|
|
|
|
return newQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader2(PointerFromQIODevice(device)))
|
|
}
|
|
|
|
func NewQXmlStreamReader3(data string) *QXmlStreamReader {
|
|
defer qt.Recovering("QXmlStreamReader::QXmlStreamReader")
|
|
|
|
return newQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader3(C.CString(data)))
|
|
}
|
|
|
|
func NewQXmlStreamReader4(data string) *QXmlStreamReader {
|
|
defer qt.Recovering("QXmlStreamReader::QXmlStreamReader")
|
|
|
|
return newQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader4(C.CString(data)))
|
|
}
|
|
|
|
func NewQXmlStreamReader5(data string) *QXmlStreamReader {
|
|
defer qt.Recovering("QXmlStreamReader::QXmlStreamReader")
|
|
|
|
return newQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader5(C.CString(data)))
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) AddData(data string) {
|
|
defer qt.Recovering("QXmlStreamReader::addData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamReader_AddData(ptr.Pointer(), C.CString(data))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) AddData2(data string) {
|
|
defer qt.Recovering("QXmlStreamReader::addData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamReader_AddData2(ptr.Pointer(), C.CString(data))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) AddData3(data string) {
|
|
defer qt.Recovering("QXmlStreamReader::addData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamReader_AddData3(ptr.Pointer(), C.CString(data))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) AddExtraNamespaceDeclaration(extraNamespaceDeclaration QXmlStreamNamespaceDeclaration_ITF) {
|
|
defer qt.Recovering("QXmlStreamReader::addExtraNamespaceDeclaration")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamReader_AddExtraNamespaceDeclaration(ptr.Pointer(), PointerFromQXmlStreamNamespaceDeclaration(extraNamespaceDeclaration))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) AtEnd() bool {
|
|
defer qt.Recovering("QXmlStreamReader::atEnd")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_AtEnd(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) CharacterOffset() int64 {
|
|
defer qt.Recovering("QXmlStreamReader::characterOffset")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QXmlStreamReader_CharacterOffset(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) Clear() {
|
|
defer qt.Recovering("QXmlStreamReader::clear")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamReader_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) ColumnNumber() int64 {
|
|
defer qt.Recovering("QXmlStreamReader::columnNumber")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QXmlStreamReader_ColumnNumber(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) Device() *QIODevice {
|
|
defer qt.Recovering("QXmlStreamReader::device")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQIODeviceFromPointer(C.QXmlStreamReader_Device(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) DocumentEncoding() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamReader::documentEncoding")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamReader_DocumentEncoding(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) DocumentVersion() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamReader::documentVersion")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamReader_DocumentVersion(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) DtdName() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamReader::dtdName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamReader_DtdName(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) DtdPublicId() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamReader::dtdPublicId")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamReader_DtdPublicId(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) DtdSystemId() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamReader::dtdSystemId")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamReader_DtdSystemId(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) EntityResolver() *QXmlStreamEntityResolver {
|
|
defer qt.Recovering("QXmlStreamReader::entityResolver")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQXmlStreamEntityResolverFromPointer(C.QXmlStreamReader_EntityResolver(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) Error() QXmlStreamReader__Error {
|
|
defer qt.Recovering("QXmlStreamReader::error")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QXmlStreamReader__Error(C.QXmlStreamReader_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) ErrorString() string {
|
|
defer qt.Recovering("QXmlStreamReader::errorString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QXmlStreamReader_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) HasError() bool {
|
|
defer qt.Recovering("QXmlStreamReader::hasError")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_HasError(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) IsCDATA() bool {
|
|
defer qt.Recovering("QXmlStreamReader::isCDATA")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_IsCDATA(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) IsCharacters() bool {
|
|
defer qt.Recovering("QXmlStreamReader::isCharacters")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_IsCharacters(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) IsComment() bool {
|
|
defer qt.Recovering("QXmlStreamReader::isComment")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_IsComment(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) IsDTD() bool {
|
|
defer qt.Recovering("QXmlStreamReader::isDTD")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_IsDTD(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) IsEndDocument() bool {
|
|
defer qt.Recovering("QXmlStreamReader::isEndDocument")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_IsEndDocument(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) IsEndElement() bool {
|
|
defer qt.Recovering("QXmlStreamReader::isEndElement")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_IsEndElement(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) IsEntityReference() bool {
|
|
defer qt.Recovering("QXmlStreamReader::isEntityReference")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_IsEntityReference(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) IsProcessingInstruction() bool {
|
|
defer qt.Recovering("QXmlStreamReader::isProcessingInstruction")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_IsProcessingInstruction(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) IsStandaloneDocument() bool {
|
|
defer qt.Recovering("QXmlStreamReader::isStandaloneDocument")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_IsStandaloneDocument(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) IsStartDocument() bool {
|
|
defer qt.Recovering("QXmlStreamReader::isStartDocument")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_IsStartDocument(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) IsStartElement() bool {
|
|
defer qt.Recovering("QXmlStreamReader::isStartElement")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_IsStartElement(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) IsWhitespace() bool {
|
|
defer qt.Recovering("QXmlStreamReader::isWhitespace")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_IsWhitespace(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) LineNumber() int64 {
|
|
defer qt.Recovering("QXmlStreamReader::lineNumber")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QXmlStreamReader_LineNumber(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) Name() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamReader::name")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamReader_Name(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) NamespaceUri() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamReader::namespaceUri")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamReader_NamespaceUri(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) Prefix() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamReader::prefix")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamReader_Prefix(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) ProcessingInstructionData() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamReader::processingInstructionData")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamReader_ProcessingInstructionData(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) ProcessingInstructionTarget() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamReader::processingInstructionTarget")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamReader_ProcessingInstructionTarget(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) QualifiedName() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamReader::qualifiedName")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamReader_QualifiedName(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) RaiseError(message string) {
|
|
defer qt.Recovering("QXmlStreamReader::raiseError")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamReader_RaiseError(ptr.Pointer(), C.CString(message))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) ReadElementText(behaviour QXmlStreamReader__ReadElementTextBehaviour) string {
|
|
defer qt.Recovering("QXmlStreamReader::readElementText")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QXmlStreamReader_ReadElementText(ptr.Pointer(), C.int(behaviour)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) ReadNext() QXmlStreamReader__TokenType {
|
|
defer qt.Recovering("QXmlStreamReader::readNext")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QXmlStreamReader__TokenType(C.QXmlStreamReader_ReadNext(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) ReadNextStartElement() bool {
|
|
defer qt.Recovering("QXmlStreamReader::readNextStartElement")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamReader_ReadNextStartElement(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) SetDevice(device QIODevice_ITF) {
|
|
defer qt.Recovering("QXmlStreamReader::setDevice")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamReader_SetDevice(ptr.Pointer(), PointerFromQIODevice(device))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) SetEntityResolver(resolver QXmlStreamEntityResolver_ITF) {
|
|
defer qt.Recovering("QXmlStreamReader::setEntityResolver")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamReader_SetEntityResolver(ptr.Pointer(), PointerFromQXmlStreamEntityResolver(resolver))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) SkipCurrentElement() {
|
|
defer qt.Recovering("QXmlStreamReader::skipCurrentElement")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamReader_SkipCurrentElement(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) Text() *QStringRef {
|
|
defer qt.Recovering("QXmlStreamReader::text")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQStringRefFromPointer(C.QXmlStreamReader_Text(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) TokenString() string {
|
|
defer qt.Recovering("QXmlStreamReader::tokenString")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.GoString(C.QXmlStreamReader_TokenString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) TokenType() QXmlStreamReader__TokenType {
|
|
defer qt.Recovering("QXmlStreamReader::tokenType")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return QXmlStreamReader__TokenType(C.QXmlStreamReader_TokenType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QXmlStreamReader) DestroyQXmlStreamReader() {
|
|
defer qt.Recovering("QXmlStreamReader::~QXmlStreamReader")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamReader_DestroyQXmlStreamReader(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QXmlStreamWriter struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QXmlStreamWriter_ITF interface {
|
|
QXmlStreamWriter_PTR() *QXmlStreamWriter
|
|
}
|
|
|
|
func (p *QXmlStreamWriter) QXmlStreamWriter_PTR() *QXmlStreamWriter {
|
|
return p
|
|
}
|
|
|
|
func (p *QXmlStreamWriter) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QXmlStreamWriter) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQXmlStreamWriter(ptr QXmlStreamWriter_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QXmlStreamWriter_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQXmlStreamWriterFromPointer(ptr unsafe.Pointer) *QXmlStreamWriter {
|
|
var n = new(QXmlStreamWriter)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQXmlStreamWriterFromPointer(ptr unsafe.Pointer) *QXmlStreamWriter {
|
|
var n = NewQXmlStreamWriterFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) AutoFormattingIndent() int {
|
|
defer qt.Recovering("QXmlStreamWriter::autoFormattingIndent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return int(C.QXmlStreamWriter_AutoFormattingIndent(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) SetAutoFormattingIndent(spacesOrTabs int) {
|
|
defer qt.Recovering("QXmlStreamWriter::setAutoFormattingIndent")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_SetAutoFormattingIndent(ptr.Pointer(), C.int(spacesOrTabs))
|
|
}
|
|
}
|
|
|
|
func NewQXmlStreamWriter() *QXmlStreamWriter {
|
|
defer qt.Recovering("QXmlStreamWriter::QXmlStreamWriter")
|
|
|
|
return newQXmlStreamWriterFromPointer(C.QXmlStreamWriter_NewQXmlStreamWriter())
|
|
}
|
|
|
|
func NewQXmlStreamWriter3(array string) *QXmlStreamWriter {
|
|
defer qt.Recovering("QXmlStreamWriter::QXmlStreamWriter")
|
|
|
|
return newQXmlStreamWriterFromPointer(C.QXmlStreamWriter_NewQXmlStreamWriter3(C.CString(array)))
|
|
}
|
|
|
|
func NewQXmlStreamWriter2(device QIODevice_ITF) *QXmlStreamWriter {
|
|
defer qt.Recovering("QXmlStreamWriter::QXmlStreamWriter")
|
|
|
|
return newQXmlStreamWriterFromPointer(C.QXmlStreamWriter_NewQXmlStreamWriter2(PointerFromQIODevice(device)))
|
|
}
|
|
|
|
func NewQXmlStreamWriter4(stri string) *QXmlStreamWriter {
|
|
defer qt.Recovering("QXmlStreamWriter::QXmlStreamWriter")
|
|
|
|
return newQXmlStreamWriterFromPointer(C.QXmlStreamWriter_NewQXmlStreamWriter4(C.CString(stri)))
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) AutoFormatting() bool {
|
|
defer qt.Recovering("QXmlStreamWriter::autoFormatting")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamWriter_AutoFormatting(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) Codec() *QTextCodec {
|
|
defer qt.Recovering("QXmlStreamWriter::codec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQTextCodecFromPointer(C.QXmlStreamWriter_Codec(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) Device() *QIODevice {
|
|
defer qt.Recovering("QXmlStreamWriter::device")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return NewQIODeviceFromPointer(C.QXmlStreamWriter_Device(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) HasError() bool {
|
|
defer qt.Recovering("QXmlStreamWriter::hasError")
|
|
|
|
if ptr.Pointer() != nil {
|
|
return C.QXmlStreamWriter_HasError(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) SetAutoFormatting(enable bool) {
|
|
defer qt.Recovering("QXmlStreamWriter::setAutoFormatting")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_SetAutoFormatting(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) SetCodec(codec QTextCodec_ITF) {
|
|
defer qt.Recovering("QXmlStreamWriter::setCodec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_SetCodec(ptr.Pointer(), PointerFromQTextCodec(codec))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) SetCodec2(codecName string) {
|
|
defer qt.Recovering("QXmlStreamWriter::setCodec")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_SetCodec2(ptr.Pointer(), C.CString(codecName))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) SetDevice(device QIODevice_ITF) {
|
|
defer qt.Recovering("QXmlStreamWriter::setDevice")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_SetDevice(ptr.Pointer(), PointerFromQIODevice(device))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteAttribute(namespaceUri string, name string, value string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeAttribute")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteAttribute(ptr.Pointer(), C.CString(namespaceUri), C.CString(name), C.CString(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteAttribute2(qualifiedName string, value string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeAttribute")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteAttribute2(ptr.Pointer(), C.CString(qualifiedName), C.CString(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteAttribute3(attribute QXmlStreamAttribute_ITF) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeAttribute")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteAttribute3(ptr.Pointer(), PointerFromQXmlStreamAttribute(attribute))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteAttributes(attributes QXmlStreamAttributes_ITF) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeAttributes")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteAttributes(ptr.Pointer(), PointerFromQXmlStreamAttributes(attributes))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteCDATA(text string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeCDATA")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteCDATA(ptr.Pointer(), C.CString(text))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteCharacters(text string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeCharacters")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteCharacters(ptr.Pointer(), C.CString(text))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteComment(text string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeComment")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteComment(ptr.Pointer(), C.CString(text))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteCurrentToken(reader QXmlStreamReader_ITF) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeCurrentToken")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteCurrentToken(ptr.Pointer(), PointerFromQXmlStreamReader(reader))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteDTD(dtd string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeDTD")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteDTD(ptr.Pointer(), C.CString(dtd))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteDefaultNamespace(namespaceUri string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeDefaultNamespace")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteDefaultNamespace(ptr.Pointer(), C.CString(namespaceUri))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteEmptyElement(namespaceUri string, name string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeEmptyElement")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteEmptyElement(ptr.Pointer(), C.CString(namespaceUri), C.CString(name))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteEmptyElement2(qualifiedName string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeEmptyElement")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteEmptyElement2(ptr.Pointer(), C.CString(qualifiedName))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteEndDocument() {
|
|
defer qt.Recovering("QXmlStreamWriter::writeEndDocument")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteEndDocument(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteEndElement() {
|
|
defer qt.Recovering("QXmlStreamWriter::writeEndElement")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteEndElement(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteEntityReference(name string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeEntityReference")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteEntityReference(ptr.Pointer(), C.CString(name))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteNamespace(namespaceUri string, prefix string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeNamespace")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteNamespace(ptr.Pointer(), C.CString(namespaceUri), C.CString(prefix))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteProcessingInstruction(target string, data string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeProcessingInstruction")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteProcessingInstruction(ptr.Pointer(), C.CString(target), C.CString(data))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteStartDocument2() {
|
|
defer qt.Recovering("QXmlStreamWriter::writeStartDocument")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteStartDocument2(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteStartDocument(version string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeStartDocument")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteStartDocument(ptr.Pointer(), C.CString(version))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteStartDocument3(version string, standalone bool) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeStartDocument")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteStartDocument3(ptr.Pointer(), C.CString(version), C.int(qt.GoBoolToInt(standalone)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteStartElement(namespaceUri string, name string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeStartElement")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteStartElement(ptr.Pointer(), C.CString(namespaceUri), C.CString(name))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteStartElement2(qualifiedName string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeStartElement")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteStartElement2(ptr.Pointer(), C.CString(qualifiedName))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteTextElement(namespaceUri string, name string, text string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeTextElement")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteTextElement(ptr.Pointer(), C.CString(namespaceUri), C.CString(name), C.CString(text))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) WriteTextElement2(qualifiedName string, text string) {
|
|
defer qt.Recovering("QXmlStreamWriter::writeTextElement")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_WriteTextElement2(ptr.Pointer(), C.CString(qualifiedName), C.CString(text))
|
|
}
|
|
}
|
|
|
|
func (ptr *QXmlStreamWriter) DestroyQXmlStreamWriter() {
|
|
defer qt.Recovering("QXmlStreamWriter::~QXmlStreamWriter")
|
|
|
|
if ptr.Pointer() != nil {
|
|
C.QXmlStreamWriter_DestroyQXmlStreamWriter(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//Qt::AlignmentFlag
|
|
type Qt__AlignmentFlag int64
|
|
|
|
const (
|
|
Qt__AlignLeft = Qt__AlignmentFlag(0x0001)
|
|
Qt__AlignLeading = Qt__AlignmentFlag(Qt__AlignLeft)
|
|
Qt__AlignRight = Qt__AlignmentFlag(0x0002)
|
|
Qt__AlignTrailing = Qt__AlignmentFlag(Qt__AlignRight)
|
|
Qt__AlignHCenter = Qt__AlignmentFlag(0x0004)
|
|
Qt__AlignJustify = Qt__AlignmentFlag(0x0008)
|
|
Qt__AlignAbsolute = Qt__AlignmentFlag(0x0010)
|
|
Qt__AlignHorizontal_Mask = Qt__AlignmentFlag(Qt__AlignLeft | Qt__AlignRight | Qt__AlignHCenter | Qt__AlignJustify | Qt__AlignAbsolute)
|
|
Qt__AlignTop = Qt__AlignmentFlag(0x0020)
|
|
Qt__AlignBottom = Qt__AlignmentFlag(0x0040)
|
|
Qt__AlignVCenter = Qt__AlignmentFlag(0x0080)
|
|
Qt__AlignBaseline = Qt__AlignmentFlag(0x0100)
|
|
Qt__AlignVertical_Mask = Qt__AlignmentFlag(Qt__AlignTop | Qt__AlignBottom | Qt__AlignVCenter | Qt__AlignBaseline)
|
|
Qt__AlignCenter = Qt__AlignmentFlag(Qt__AlignVCenter | Qt__AlignHCenter)
|
|
)
|
|
|
|
//Qt::AnchorPoint
|
|
type Qt__AnchorPoint int64
|
|
|
|
const (
|
|
Qt__AnchorLeft = Qt__AnchorPoint(0)
|
|
Qt__AnchorHorizontalCenter = Qt__AnchorPoint(1)
|
|
Qt__AnchorRight = Qt__AnchorPoint(2)
|
|
Qt__AnchorTop = Qt__AnchorPoint(3)
|
|
Qt__AnchorVerticalCenter = Qt__AnchorPoint(4)
|
|
Qt__AnchorBottom = Qt__AnchorPoint(5)
|
|
)
|
|
|
|
//Qt::ApplicationAttribute
|
|
type Qt__ApplicationAttribute int64
|
|
|
|
const (
|
|
Qt__AA_ImmediateWidgetCreation = Qt__ApplicationAttribute(0)
|
|
Qt__AA_MSWindowsUseDirect3DByDefault = Qt__ApplicationAttribute(1)
|
|
Qt__AA_DontShowIconsInMenus = Qt__ApplicationAttribute(2)
|
|
Qt__AA_NativeWindows = Qt__ApplicationAttribute(3)
|
|
Qt__AA_DontCreateNativeWidgetSiblings = Qt__ApplicationAttribute(4)
|
|
Qt__AA_MacPluginApplication = Qt__ApplicationAttribute(5)
|
|
Qt__AA_DontUseNativeMenuBar = Qt__ApplicationAttribute(6)
|
|
Qt__AA_MacDontSwapCtrlAndMeta = Qt__ApplicationAttribute(7)
|
|
Qt__AA_Use96Dpi = Qt__ApplicationAttribute(8)
|
|
Qt__AA_X11InitThreads = Qt__ApplicationAttribute(10)
|
|
Qt__AA_SynthesizeTouchForUnhandledMouseEvents = Qt__ApplicationAttribute(11)
|
|
Qt__AA_SynthesizeMouseForUnhandledTouchEvents = Qt__ApplicationAttribute(12)
|
|
Qt__AA_UseHighDpiPixmaps = Qt__ApplicationAttribute(13)
|
|
Qt__AA_ForceRasterWidgets = Qt__ApplicationAttribute(14)
|
|
Qt__AA_UseDesktopOpenGL = Qt__ApplicationAttribute(15)
|
|
Qt__AA_UseOpenGLES = Qt__ApplicationAttribute(16)
|
|
Qt__AA_UseSoftwareOpenGL = Qt__ApplicationAttribute(17)
|
|
Qt__AA_ShareOpenGLContexts = Qt__ApplicationAttribute(18)
|
|
Qt__AA_SetPalette = Qt__ApplicationAttribute(19)
|
|
Qt__AA_EnableHighDpiScaling = Qt__ApplicationAttribute(20)
|
|
Qt__AA_DisableHighDpiScaling = Qt__ApplicationAttribute(21)
|
|
Qt__AA_AttributeCount = Qt__ApplicationAttribute(22)
|
|
)
|
|
|
|
//Qt::ApplicationState
|
|
type Qt__ApplicationState int64
|
|
|
|
const (
|
|
Qt__ApplicationSuspended = Qt__ApplicationState(0x00000000)
|
|
Qt__ApplicationHidden = Qt__ApplicationState(0x00000001)
|
|
Qt__ApplicationInactive = Qt__ApplicationState(0x00000002)
|
|
Qt__ApplicationActive = Qt__ApplicationState(0x00000004)
|
|
)
|
|
|
|
//Qt::ArrowType
|
|
type Qt__ArrowType int64
|
|
|
|
const (
|
|
Qt__NoArrow = Qt__ArrowType(0)
|
|
Qt__UpArrow = Qt__ArrowType(1)
|
|
Qt__DownArrow = Qt__ArrowType(2)
|
|
Qt__LeftArrow = Qt__ArrowType(3)
|
|
Qt__RightArrow = Qt__ArrowType(4)
|
|
)
|
|
|
|
//Qt::AspectRatioMode
|
|
type Qt__AspectRatioMode int64
|
|
|
|
const (
|
|
Qt__IgnoreAspectRatio = Qt__AspectRatioMode(0)
|
|
Qt__KeepAspectRatio = Qt__AspectRatioMode(1)
|
|
Qt__KeepAspectRatioByExpanding = Qt__AspectRatioMode(2)
|
|
)
|
|
|
|
//Qt::Axis
|
|
type Qt__Axis int64
|
|
|
|
const (
|
|
Qt__XAxis = Qt__Axis(0)
|
|
Qt__YAxis = Qt__Axis(1)
|
|
Qt__ZAxis = Qt__Axis(2)
|
|
)
|
|
|
|
//Qt::BGMode
|
|
type Qt__BGMode int64
|
|
|
|
const (
|
|
Qt__TransparentMode = Qt__BGMode(0)
|
|
Qt__OpaqueMode = Qt__BGMode(1)
|
|
)
|
|
|
|
//Qt::BrushStyle
|
|
type Qt__BrushStyle int64
|
|
|
|
var (
|
|
Qt__NoBrush = Qt__BrushStyle(0)
|
|
Qt__SolidPattern = Qt__BrushStyle(1)
|
|
Qt__Dense1Pattern = Qt__BrushStyle(2)
|
|
Qt__Dense2Pattern = Qt__BrushStyle(3)
|
|
Qt__Dense3Pattern = Qt__BrushStyle(4)
|
|
Qt__Dense4Pattern = Qt__BrushStyle(5)
|
|
Qt__Dense5Pattern = Qt__BrushStyle(6)
|
|
Qt__Dense6Pattern = Qt__BrushStyle(7)
|
|
Qt__Dense7Pattern = Qt__BrushStyle(8)
|
|
Qt__HorPattern = Qt__BrushStyle(9)
|
|
Qt__VerPattern = Qt__BrushStyle(10)
|
|
Qt__CrossPattern = Qt__BrushStyle(11)
|
|
Qt__BDiagPattern = Qt__BrushStyle(12)
|
|
Qt__FDiagPattern = Qt__BrushStyle(13)
|
|
Qt__DiagCrossPattern = Qt__BrushStyle(14)
|
|
Qt__LinearGradientPattern = Qt__BrushStyle(15)
|
|
Qt__RadialGradientPattern = Qt__BrushStyle(16)
|
|
Qt__ConicalGradientPattern = Qt__BrushStyle(17)
|
|
Qt__TexturePattern = Qt__BrushStyle(24)
|
|
)
|
|
|
|
//Qt::CaseSensitivity
|
|
type Qt__CaseSensitivity int64
|
|
|
|
const (
|
|
Qt__CaseInsensitive = Qt__CaseSensitivity(0)
|
|
Qt__CaseSensitive = Qt__CaseSensitivity(1)
|
|
)
|
|
|
|
//Qt::CheckState
|
|
type Qt__CheckState int64
|
|
|
|
const (
|
|
Qt__Unchecked = Qt__CheckState(0)
|
|
Qt__PartiallyChecked = Qt__CheckState(1)
|
|
Qt__Checked = Qt__CheckState(2)
|
|
)
|
|
|
|
//Qt::ClipOperation
|
|
type Qt__ClipOperation int64
|
|
|
|
const (
|
|
Qt__NoClip = Qt__ClipOperation(0)
|
|
Qt__ReplaceClip = Qt__ClipOperation(1)
|
|
Qt__IntersectClip = Qt__ClipOperation(2)
|
|
)
|
|
|
|
//Qt::ConnectionType
|
|
type Qt__ConnectionType int64
|
|
|
|
const (
|
|
Qt__AutoConnection = Qt__ConnectionType(0)
|
|
Qt__DirectConnection = Qt__ConnectionType(1)
|
|
Qt__QueuedConnection = Qt__ConnectionType(2)
|
|
Qt__BlockingQueuedConnection = Qt__ConnectionType(3)
|
|
Qt__UniqueConnection = Qt__ConnectionType(0x80)
|
|
)
|
|
|
|
//Qt::ContextMenuPolicy
|
|
type Qt__ContextMenuPolicy int64
|
|
|
|
const (
|
|
Qt__NoContextMenu = Qt__ContextMenuPolicy(0)
|
|
Qt__DefaultContextMenu = Qt__ContextMenuPolicy(1)
|
|
Qt__ActionsContextMenu = Qt__ContextMenuPolicy(2)
|
|
Qt__CustomContextMenu = Qt__ContextMenuPolicy(3)
|
|
Qt__PreventContextMenu = Qt__ContextMenuPolicy(4)
|
|
)
|
|
|
|
//Qt::CoordinateSystem
|
|
type Qt__CoordinateSystem int64
|
|
|
|
const (
|
|
Qt__DeviceCoordinates = Qt__CoordinateSystem(0)
|
|
Qt__LogicalCoordinates = Qt__CoordinateSystem(1)
|
|
)
|
|
|
|
//Qt::Corner
|
|
type Qt__Corner int64
|
|
|
|
const (
|
|
Qt__TopLeftCorner = Qt__Corner(0x00000)
|
|
Qt__TopRightCorner = Qt__Corner(0x00001)
|
|
Qt__BottomLeftCorner = Qt__Corner(0x00002)
|
|
Qt__BottomRightCorner = Qt__Corner(0x00003)
|
|
)
|
|
|
|
//Qt::CursorMoveStyle
|
|
type Qt__CursorMoveStyle int64
|
|
|
|
var (
|
|
Qt__LogicalMoveStyle = Qt__CursorMoveStyle(0)
|
|
Qt__VisualMoveStyle = Qt__CursorMoveStyle(1)
|
|
)
|
|
|
|
//Qt::CursorShape
|
|
type Qt__CursorShape int64
|
|
|
|
const (
|
|
Qt__ArrowCursor = Qt__CursorShape(0)
|
|
Qt__UpArrowCursor = Qt__CursorShape(1)
|
|
Qt__CrossCursor = Qt__CursorShape(2)
|
|
Qt__WaitCursor = Qt__CursorShape(3)
|
|
Qt__IBeamCursor = Qt__CursorShape(4)
|
|
Qt__SizeVerCursor = Qt__CursorShape(5)
|
|
Qt__SizeHorCursor = Qt__CursorShape(6)
|
|
Qt__SizeBDiagCursor = Qt__CursorShape(7)
|
|
Qt__SizeFDiagCursor = Qt__CursorShape(8)
|
|
Qt__SizeAllCursor = Qt__CursorShape(9)
|
|
Qt__BlankCursor = Qt__CursorShape(10)
|
|
Qt__SplitVCursor = Qt__CursorShape(11)
|
|
Qt__SplitHCursor = Qt__CursorShape(12)
|
|
Qt__PointingHandCursor = Qt__CursorShape(13)
|
|
Qt__ForbiddenCursor = Qt__CursorShape(14)
|
|
Qt__WhatsThisCursor = Qt__CursorShape(15)
|
|
Qt__BusyCursor = Qt__CursorShape(16)
|
|
Qt__OpenHandCursor = Qt__CursorShape(17)
|
|
Qt__ClosedHandCursor = Qt__CursorShape(18)
|
|
Qt__DragCopyCursor = Qt__CursorShape(19)
|
|
Qt__DragMoveCursor = Qt__CursorShape(20)
|
|
Qt__DragLinkCursor = Qt__CursorShape(21)
|
|
Qt__LastCursor = Qt__CursorShape(Qt__DragLinkCursor)
|
|
Qt__BitmapCursor = Qt__CursorShape(24)
|
|
Qt__CustomCursor = Qt__CursorShape(25)
|
|
)
|
|
|
|
//Qt::DateFormat
|
|
type Qt__DateFormat int64
|
|
|
|
var (
|
|
Qt__TextDate = Qt__DateFormat(0)
|
|
Qt__ISODate = Qt__DateFormat(1)
|
|
Qt__SystemLocaleDate = Qt__DateFormat(2)
|
|
Qt__LocalDate = Qt__DateFormat(Qt__SystemLocaleDate)
|
|
Qt__LocaleDate = Qt__DateFormat(C.Qt_LocaleDate_Type())
|
|
Qt__SystemLocaleShortDate = Qt__DateFormat(C.Qt_SystemLocaleShortDate_Type())
|
|
Qt__SystemLocaleLongDate = Qt__DateFormat(C.Qt_SystemLocaleLongDate_Type())
|
|
Qt__DefaultLocaleShortDate = Qt__DateFormat(C.Qt_DefaultLocaleShortDate_Type())
|
|
Qt__DefaultLocaleLongDate = Qt__DateFormat(C.Qt_DefaultLocaleLongDate_Type())
|
|
Qt__RFC2822Date = Qt__DateFormat(C.Qt_RFC2822Date_Type())
|
|
)
|
|
|
|
//Qt::DayOfWeek
|
|
type Qt__DayOfWeek int64
|
|
|
|
const (
|
|
Qt__Monday = Qt__DayOfWeek(1)
|
|
Qt__Tuesday = Qt__DayOfWeek(2)
|
|
Qt__Wednesday = Qt__DayOfWeek(3)
|
|
Qt__Thursday = Qt__DayOfWeek(4)
|
|
Qt__Friday = Qt__DayOfWeek(5)
|
|
Qt__Saturday = Qt__DayOfWeek(6)
|
|
Qt__Sunday = Qt__DayOfWeek(7)
|
|
)
|
|
|
|
//Qt::DockWidgetArea
|
|
type Qt__DockWidgetArea int64
|
|
|
|
const (
|
|
Qt__LeftDockWidgetArea = Qt__DockWidgetArea(0x1)
|
|
Qt__RightDockWidgetArea = Qt__DockWidgetArea(0x2)
|
|
Qt__TopDockWidgetArea = Qt__DockWidgetArea(0x4)
|
|
Qt__BottomDockWidgetArea = Qt__DockWidgetArea(0x8)
|
|
Qt__DockWidgetArea_Mask = Qt__DockWidgetArea(0xf)
|
|
Qt__AllDockWidgetAreas = Qt__DockWidgetArea(Qt__DockWidgetArea_Mask)
|
|
Qt__NoDockWidgetArea = Qt__DockWidgetArea(0)
|
|
)
|
|
|
|
//Qt::DropAction
|
|
type Qt__DropAction int64
|
|
|
|
const (
|
|
Qt__CopyAction = Qt__DropAction(0x1)
|
|
Qt__MoveAction = Qt__DropAction(0x2)
|
|
Qt__LinkAction = Qt__DropAction(0x4)
|
|
Qt__ActionMask = Qt__DropAction(0xff)
|
|
Qt__TargetMoveAction = Qt__DropAction(0x8002)
|
|
Qt__IgnoreAction = Qt__DropAction(0x0)
|
|
)
|
|
|
|
//Qt::Edge
|
|
type Qt__Edge int64
|
|
|
|
const (
|
|
Qt__TopEdge = Qt__Edge(0x00001)
|
|
Qt__LeftEdge = Qt__Edge(0x00002)
|
|
Qt__RightEdge = Qt__Edge(0x00004)
|
|
Qt__BottomEdge = Qt__Edge(0x00008)
|
|
)
|
|
|
|
//Qt::EnterKeyType
|
|
type Qt__EnterKeyType int64
|
|
|
|
const (
|
|
Qt__EnterKeyDefault = Qt__EnterKeyType(0)
|
|
Qt__EnterKeyReturn = Qt__EnterKeyType(1)
|
|
Qt__EnterKeyDone = Qt__EnterKeyType(2)
|
|
Qt__EnterKeyGo = Qt__EnterKeyType(3)
|
|
Qt__EnterKeySend = Qt__EnterKeyType(4)
|
|
Qt__EnterKeySearch = Qt__EnterKeyType(5)
|
|
Qt__EnterKeyNext = Qt__EnterKeyType(6)
|
|
Qt__EnterKeyPrevious = Qt__EnterKeyType(7)
|
|
)
|
|
|
|
//Qt::EventPriority
|
|
type Qt__EventPriority int64
|
|
|
|
const (
|
|
Qt__HighEventPriority = Qt__EventPriority(1)
|
|
Qt__NormalEventPriority = Qt__EventPriority(0)
|
|
Qt__LowEventPriority = Qt__EventPriority(-1)
|
|
)
|
|
|
|
//Qt::FillRule
|
|
type Qt__FillRule int64
|
|
|
|
const (
|
|
Qt__OddEvenFill = Qt__FillRule(0)
|
|
Qt__WindingFill = Qt__FillRule(1)
|
|
)
|
|
|
|
//Qt::FindChildOption
|
|
type Qt__FindChildOption int64
|
|
|
|
const (
|
|
Qt__FindDirectChildrenOnly = Qt__FindChildOption(0x0)
|
|
Qt__FindChildrenRecursively = Qt__FindChildOption(0x1)
|
|
)
|
|
|
|
//Qt::FocusPolicy
|
|
type Qt__FocusPolicy int64
|
|
|
|
const (
|
|
Qt__NoFocus = Qt__FocusPolicy(0)
|
|
Qt__TabFocus = Qt__FocusPolicy(0x1)
|
|
Qt__ClickFocus = Qt__FocusPolicy(0x2)
|
|
Qt__StrongFocus = Qt__FocusPolicy(Qt__TabFocus | Qt__ClickFocus | 0x8)
|
|
Qt__WheelFocus = Qt__FocusPolicy(Qt__StrongFocus | 0x4)
|
|
)
|
|
|
|
//Qt::FocusReason
|
|
type Qt__FocusReason int64
|
|
|
|
const (
|
|
Qt__MouseFocusReason = Qt__FocusReason(0)
|
|
Qt__TabFocusReason = Qt__FocusReason(1)
|
|
Qt__BacktabFocusReason = Qt__FocusReason(2)
|
|
Qt__ActiveWindowFocusReason = Qt__FocusReason(3)
|
|
Qt__PopupFocusReason = Qt__FocusReason(4)
|
|
Qt__ShortcutFocusReason = Qt__FocusReason(5)
|
|
Qt__MenuBarFocusReason = Qt__FocusReason(6)
|
|
Qt__OtherFocusReason = Qt__FocusReason(7)
|
|
Qt__NoFocusReason = Qt__FocusReason(8)
|
|
)
|
|
|
|
//Qt::GestureFlag
|
|
type Qt__GestureFlag int64
|
|
|
|
const (
|
|
Qt__DontStartGestureOnChildren = Qt__GestureFlag(0x01)
|
|
Qt__ReceivePartialGestures = Qt__GestureFlag(0x02)
|
|
Qt__IgnoredGesturesPropagateToParent = Qt__GestureFlag(0x04)
|
|
)
|
|
|
|
//Qt::GestureState
|
|
type Qt__GestureState int64
|
|
|
|
const (
|
|
Qt__NoGesture = Qt__GestureState(0)
|
|
Qt__GestureStarted = Qt__GestureState(1)
|
|
Qt__GestureUpdated = Qt__GestureState(2)
|
|
Qt__GestureFinished = Qt__GestureState(3)
|
|
Qt__GestureCanceled = Qt__GestureState(4)
|
|
)
|
|
|
|
//Qt::GestureType
|
|
type Qt__GestureType int64
|
|
|
|
var (
|
|
Qt__TapGesture = Qt__GestureType(1)
|
|
Qt__TapAndHoldGesture = Qt__GestureType(2)
|
|
Qt__PanGesture = Qt__GestureType(3)
|
|
Qt__PinchGesture = Qt__GestureType(4)
|
|
Qt__SwipeGesture = Qt__GestureType(5)
|
|
Qt__CustomGesture = Qt__GestureType(0x0100)
|
|
Qt__LastGestureType = Qt__GestureType(C.Qt_LastGestureType_Type())
|
|
)
|
|
|
|
//Qt::GlobalColor
|
|
type Qt__GlobalColor int64
|
|
|
|
const (
|
|
Qt__color0 = Qt__GlobalColor(0)
|
|
Qt__color1 = Qt__GlobalColor(1)
|
|
Qt__black = Qt__GlobalColor(2)
|
|
Qt__white = Qt__GlobalColor(3)
|
|
Qt__darkGray = Qt__GlobalColor(4)
|
|
Qt__gray = Qt__GlobalColor(5)
|
|
Qt__lightGray = Qt__GlobalColor(6)
|
|
Qt__red = Qt__GlobalColor(7)
|
|
Qt__green = Qt__GlobalColor(8)
|
|
Qt__blue = Qt__GlobalColor(9)
|
|
Qt__cyan = Qt__GlobalColor(10)
|
|
Qt__magenta = Qt__GlobalColor(11)
|
|
Qt__yellow = Qt__GlobalColor(12)
|
|
Qt__darkRed = Qt__GlobalColor(13)
|
|
Qt__darkGreen = Qt__GlobalColor(14)
|
|
Qt__darkBlue = Qt__GlobalColor(15)
|
|
Qt__darkCyan = Qt__GlobalColor(16)
|
|
Qt__darkMagenta = Qt__GlobalColor(17)
|
|
Qt__darkYellow = Qt__GlobalColor(18)
|
|
Qt__transparent = Qt__GlobalColor(19)
|
|
)
|
|
|
|
//Qt::HitTestAccuracy
|
|
type Qt__HitTestAccuracy int64
|
|
|
|
const (
|
|
Qt__ExactHit = Qt__HitTestAccuracy(0)
|
|
Qt__FuzzyHit = Qt__HitTestAccuracy(1)
|
|
)
|
|
|
|
//Qt::ImageConversionFlag
|
|
type Qt__ImageConversionFlag int64
|
|
|
|
const (
|
|
Qt__ColorMode_Mask = Qt__ImageConversionFlag(0x00000003)
|
|
Qt__AutoColor = Qt__ImageConversionFlag(0x00000000)
|
|
Qt__ColorOnly = Qt__ImageConversionFlag(0x00000003)
|
|
Qt__MonoOnly = Qt__ImageConversionFlag(0x00000002)
|
|
Qt__AlphaDither_Mask = Qt__ImageConversionFlag(0x0000000c)
|
|
Qt__ThresholdAlphaDither = Qt__ImageConversionFlag(0x00000000)
|
|
Qt__OrderedAlphaDither = Qt__ImageConversionFlag(0x00000004)
|
|
Qt__DiffuseAlphaDither = Qt__ImageConversionFlag(0x00000008)
|
|
Qt__NoAlpha = Qt__ImageConversionFlag(0x0000000c)
|
|
Qt__Dither_Mask = Qt__ImageConversionFlag(0x00000030)
|
|
Qt__DiffuseDither = Qt__ImageConversionFlag(0x00000000)
|
|
Qt__OrderedDither = Qt__ImageConversionFlag(0x00000010)
|
|
Qt__ThresholdDither = Qt__ImageConversionFlag(0x00000020)
|
|
Qt__DitherMode_Mask = Qt__ImageConversionFlag(0x000000c0)
|
|
Qt__AutoDither = Qt__ImageConversionFlag(0x00000000)
|
|
Qt__PreferDither = Qt__ImageConversionFlag(0x00000040)
|
|
Qt__AvoidDither = Qt__ImageConversionFlag(0x00000080)
|
|
Qt__NoOpaqueDetection = Qt__ImageConversionFlag(0x00000100)
|
|
Qt__NoFormatConversion = Qt__ImageConversionFlag(0x00000200)
|
|
)
|
|
|
|
//Qt::InputMethodHint
|
|
type Qt__InputMethodHint int64
|
|
|
|
const (
|
|
Qt__ImhNone = Qt__InputMethodHint(0x0)
|
|
Qt__ImhHiddenText = Qt__InputMethodHint(0x1)
|
|
Qt__ImhSensitiveData = Qt__InputMethodHint(0x2)
|
|
Qt__ImhNoAutoUppercase = Qt__InputMethodHint(0x4)
|
|
Qt__ImhPreferNumbers = Qt__InputMethodHint(0x8)
|
|
Qt__ImhPreferUppercase = Qt__InputMethodHint(0x10)
|
|
Qt__ImhPreferLowercase = Qt__InputMethodHint(0x20)
|
|
Qt__ImhNoPredictiveText = Qt__InputMethodHint(0x40)
|
|
Qt__ImhDate = Qt__InputMethodHint(0x80)
|
|
Qt__ImhTime = Qt__InputMethodHint(0x100)
|
|
Qt__ImhPreferLatin = Qt__InputMethodHint(0x200)
|
|
Qt__ImhMultiLine = Qt__InputMethodHint(0x400)
|
|
Qt__ImhDigitsOnly = Qt__InputMethodHint(0x10000)
|
|
Qt__ImhFormattedNumbersOnly = Qt__InputMethodHint(0x20000)
|
|
Qt__ImhUppercaseOnly = Qt__InputMethodHint(0x40000)
|
|
Qt__ImhLowercaseOnly = Qt__InputMethodHint(0x80000)
|
|
Qt__ImhDialableCharactersOnly = Qt__InputMethodHint(0x100000)
|
|
Qt__ImhEmailCharactersOnly = Qt__InputMethodHint(0x200000)
|
|
Qt__ImhUrlCharactersOnly = Qt__InputMethodHint(0x400000)
|
|
Qt__ImhLatinOnly = Qt__InputMethodHint(0x800000)
|
|
Qt__ImhExclusiveInputMask = Qt__InputMethodHint(0xffff0000)
|
|
)
|
|
|
|
//Qt::InputMethodQuery
|
|
type Qt__InputMethodQuery int64
|
|
|
|
const (
|
|
Qt__ImEnabled = Qt__InputMethodQuery(0x1)
|
|
Qt__ImCursorRectangle = Qt__InputMethodQuery(0x2)
|
|
Qt__ImMicroFocus = Qt__InputMethodQuery(0x2)
|
|
Qt__ImFont = Qt__InputMethodQuery(0x4)
|
|
Qt__ImCursorPosition = Qt__InputMethodQuery(0x8)
|
|
Qt__ImSurroundingText = Qt__InputMethodQuery(0x10)
|
|
Qt__ImCurrentSelection = Qt__InputMethodQuery(0x20)
|
|
Qt__ImMaximumTextLength = Qt__InputMethodQuery(0x40)
|
|
Qt__ImAnchorPosition = Qt__InputMethodQuery(0x80)
|
|
Qt__ImHints = Qt__InputMethodQuery(0x100)
|
|
Qt__ImPreferredLanguage = Qt__InputMethodQuery(0x200)
|
|
Qt__ImAbsolutePosition = Qt__InputMethodQuery(0x400)
|
|
Qt__ImTextBeforeCursor = Qt__InputMethodQuery(0x800)
|
|
Qt__ImTextAfterCursor = Qt__InputMethodQuery(0x1000)
|
|
Qt__ImEnterKeyType = Qt__InputMethodQuery(0x2000)
|
|
Qt__ImPlatformData = Qt__InputMethodQuery(0x80000000)
|
|
Qt__ImQueryInput = Qt__InputMethodQuery(Qt__ImCursorRectangle | Qt__ImCursorPosition | Qt__ImSurroundingText | Qt__ImCurrentSelection | Qt__ImAnchorPosition)
|
|
Qt__ImQueryAll = Qt__InputMethodQuery(0xffffffff)
|
|
)
|
|
|
|
//Qt::ItemDataRole
|
|
type Qt__ItemDataRole int64
|
|
|
|
const (
|
|
Qt__DisplayRole = Qt__ItemDataRole(0)
|
|
Qt__DecorationRole = Qt__ItemDataRole(1)
|
|
Qt__EditRole = Qt__ItemDataRole(2)
|
|
Qt__ToolTipRole = Qt__ItemDataRole(3)
|
|
Qt__StatusTipRole = Qt__ItemDataRole(4)
|
|
Qt__WhatsThisRole = Qt__ItemDataRole(5)
|
|
Qt__FontRole = Qt__ItemDataRole(6)
|
|
Qt__TextAlignmentRole = Qt__ItemDataRole(7)
|
|
Qt__BackgroundColorRole = Qt__ItemDataRole(8)
|
|
Qt__BackgroundRole = Qt__ItemDataRole(8)
|
|
Qt__TextColorRole = Qt__ItemDataRole(9)
|
|
Qt__ForegroundRole = Qt__ItemDataRole(9)
|
|
Qt__CheckStateRole = Qt__ItemDataRole(10)
|
|
Qt__AccessibleTextRole = Qt__ItemDataRole(11)
|
|
Qt__AccessibleDescriptionRole = Qt__ItemDataRole(12)
|
|
Qt__SizeHintRole = Qt__ItemDataRole(13)
|
|
Qt__InitialSortOrderRole = Qt__ItemDataRole(14)
|
|
Qt__DisplayPropertyRole = Qt__ItemDataRole(27)
|
|
Qt__DecorationPropertyRole = Qt__ItemDataRole(28)
|
|
Qt__ToolTipPropertyRole = Qt__ItemDataRole(29)
|
|
Qt__StatusTipPropertyRole = Qt__ItemDataRole(30)
|
|
Qt__WhatsThisPropertyRole = Qt__ItemDataRole(31)
|
|
Qt__UserRole = Qt__ItemDataRole(0x0100)
|
|
)
|
|
|
|
//Qt::ItemFlag
|
|
type Qt__ItemFlag int64
|
|
|
|
const (
|
|
Qt__NoItemFlags = Qt__ItemFlag(0)
|
|
Qt__ItemIsSelectable = Qt__ItemFlag(1)
|
|
Qt__ItemIsEditable = Qt__ItemFlag(2)
|
|
Qt__ItemIsDragEnabled = Qt__ItemFlag(4)
|
|
Qt__ItemIsDropEnabled = Qt__ItemFlag(8)
|
|
Qt__ItemIsUserCheckable = Qt__ItemFlag(16)
|
|
Qt__ItemIsEnabled = Qt__ItemFlag(32)
|
|
Qt__ItemIsAutoTristate = Qt__ItemFlag(64)
|
|
Qt__ItemIsTristate = Qt__ItemFlag(Qt__ItemIsAutoTristate)
|
|
Qt__ItemNeverHasChildren = Qt__ItemFlag(128)
|
|
Qt__ItemIsUserTristate = Qt__ItemFlag(256)
|
|
)
|
|
|
|
//Qt::ItemSelectionMode
|
|
type Qt__ItemSelectionMode int64
|
|
|
|
const (
|
|
Qt__ContainsItemShape = Qt__ItemSelectionMode(0x0)
|
|
Qt__IntersectsItemShape = Qt__ItemSelectionMode(0x1)
|
|
Qt__ContainsItemBoundingRect = Qt__ItemSelectionMode(0x2)
|
|
Qt__IntersectsItemBoundingRect = Qt__ItemSelectionMode(0x3)
|
|
)
|
|
|
|
//Qt::ItemSelectionOperation
|
|
type Qt__ItemSelectionOperation int64
|
|
|
|
const (
|
|
Qt__ReplaceSelection = Qt__ItemSelectionOperation(0)
|
|
Qt__AddToSelection = Qt__ItemSelectionOperation(1)
|
|
)
|
|
|
|
//Qt::Key
|
|
type Qt__Key int64
|
|
|
|
const (
|
|
Qt__Key_Escape = Qt__Key(0x01000000)
|
|
Qt__Key_Tab = Qt__Key(0x01000001)
|
|
Qt__Key_Backtab = Qt__Key(0x01000002)
|
|
Qt__Key_Backspace = Qt__Key(0x01000003)
|
|
Qt__Key_Return = Qt__Key(0x01000004)
|
|
Qt__Key_Enter = Qt__Key(0x01000005)
|
|
Qt__Key_Insert = Qt__Key(0x01000006)
|
|
Qt__Key_Delete = Qt__Key(0x01000007)
|
|
Qt__Key_Pause = Qt__Key(0x01000008)
|
|
Qt__Key_Print = Qt__Key(0x01000009)
|
|
Qt__Key_SysReq = Qt__Key(0x0100000a)
|
|
Qt__Key_Clear = Qt__Key(0x0100000b)
|
|
Qt__Key_Home = Qt__Key(0x01000010)
|
|
Qt__Key_End = Qt__Key(0x01000011)
|
|
Qt__Key_Left = Qt__Key(0x01000012)
|
|
Qt__Key_Up = Qt__Key(0x01000013)
|
|
Qt__Key_Right = Qt__Key(0x01000014)
|
|
Qt__Key_Down = Qt__Key(0x01000015)
|
|
Qt__Key_PageUp = Qt__Key(0x01000016)
|
|
Qt__Key_PageDown = Qt__Key(0x01000017)
|
|
Qt__Key_Shift = Qt__Key(0x01000020)
|
|
Qt__Key_Control = Qt__Key(0x01000021)
|
|
Qt__Key_Meta = Qt__Key(0x01000022)
|
|
Qt__Key_Alt = Qt__Key(0x01000023)
|
|
Qt__Key_CapsLock = Qt__Key(0x01000024)
|
|
Qt__Key_NumLock = Qt__Key(0x01000025)
|
|
Qt__Key_ScrollLock = Qt__Key(0x01000026)
|
|
Qt__Key_F1 = Qt__Key(0x01000030)
|
|
Qt__Key_F2 = Qt__Key(0x01000031)
|
|
Qt__Key_F3 = Qt__Key(0x01000032)
|
|
Qt__Key_F4 = Qt__Key(0x01000033)
|
|
Qt__Key_F5 = Qt__Key(0x01000034)
|
|
Qt__Key_F6 = Qt__Key(0x01000035)
|
|
Qt__Key_F7 = Qt__Key(0x01000036)
|
|
Qt__Key_F8 = Qt__Key(0x01000037)
|
|
Qt__Key_F9 = Qt__Key(0x01000038)
|
|
Qt__Key_F10 = Qt__Key(0x01000039)
|
|
Qt__Key_F11 = Qt__Key(0x0100003a)
|
|
Qt__Key_F12 = Qt__Key(0x0100003b)
|
|
Qt__Key_F13 = Qt__Key(0x0100003c)
|
|
Qt__Key_F14 = Qt__Key(0x0100003d)
|
|
Qt__Key_F15 = Qt__Key(0x0100003e)
|
|
Qt__Key_F16 = Qt__Key(0x0100003f)
|
|
Qt__Key_F17 = Qt__Key(0x01000040)
|
|
Qt__Key_F18 = Qt__Key(0x01000041)
|
|
Qt__Key_F19 = Qt__Key(0x01000042)
|
|
Qt__Key_F20 = Qt__Key(0x01000043)
|
|
Qt__Key_F21 = Qt__Key(0x01000044)
|
|
Qt__Key_F22 = Qt__Key(0x01000045)
|
|
Qt__Key_F23 = Qt__Key(0x01000046)
|
|
Qt__Key_F24 = Qt__Key(0x01000047)
|
|
Qt__Key_F25 = Qt__Key(0x01000048)
|
|
Qt__Key_F26 = Qt__Key(0x01000049)
|
|
Qt__Key_F27 = Qt__Key(0x0100004a)
|
|
Qt__Key_F28 = Qt__Key(0x0100004b)
|
|
Qt__Key_F29 = Qt__Key(0x0100004c)
|
|
Qt__Key_F30 = Qt__Key(0x0100004d)
|
|
Qt__Key_F31 = Qt__Key(0x0100004e)
|
|
Qt__Key_F32 = Qt__Key(0x0100004f)
|
|
Qt__Key_F33 = Qt__Key(0x01000050)
|
|
Qt__Key_F34 = Qt__Key(0x01000051)
|
|
Qt__Key_F35 = Qt__Key(0x01000052)
|
|
Qt__Key_Super_L = Qt__Key(0x01000053)
|
|
Qt__Key_Super_R = Qt__Key(0x01000054)
|
|
Qt__Key_Menu = Qt__Key(0x01000055)
|
|
Qt__Key_Hyper_L = Qt__Key(0x01000056)
|
|
Qt__Key_Hyper_R = Qt__Key(0x01000057)
|
|
Qt__Key_Help = Qt__Key(0x01000058)
|
|
Qt__Key_Direction_L = Qt__Key(0x01000059)
|
|
Qt__Key_Direction_R = Qt__Key(0x01000060)
|
|
Qt__Key_Space = Qt__Key(0x20)
|
|
Qt__Key_Any = Qt__Key(Qt__Key_Space)
|
|
Qt__Key_Exclam = Qt__Key(0x21)
|
|
Qt__Key_QuoteDbl = Qt__Key(0x22)
|
|
Qt__Key_NumberSign = Qt__Key(0x23)
|
|
Qt__Key_Dollar = Qt__Key(0x24)
|
|
Qt__Key_Percent = Qt__Key(0x25)
|
|
Qt__Key_Ampersand = Qt__Key(0x26)
|
|
Qt__Key_Apostrophe = Qt__Key(0x27)
|
|
Qt__Key_ParenLeft = Qt__Key(0x28)
|
|
Qt__Key_ParenRight = Qt__Key(0x29)
|
|
Qt__Key_Asterisk = Qt__Key(0x2a)
|
|
Qt__Key_Plus = Qt__Key(0x2b)
|
|
Qt__Key_Comma = Qt__Key(0x2c)
|
|
Qt__Key_Minus = Qt__Key(0x2d)
|
|
Qt__Key_Period = Qt__Key(0x2e)
|
|
Qt__Key_Slash = Qt__Key(0x2f)
|
|
Qt__Key_0 = Qt__Key(0x30)
|
|
Qt__Key_1 = Qt__Key(0x31)
|
|
Qt__Key_2 = Qt__Key(0x32)
|
|
Qt__Key_3 = Qt__Key(0x33)
|
|
Qt__Key_4 = Qt__Key(0x34)
|
|
Qt__Key_5 = Qt__Key(0x35)
|
|
Qt__Key_6 = Qt__Key(0x36)
|
|
Qt__Key_7 = Qt__Key(0x37)
|
|
Qt__Key_8 = Qt__Key(0x38)
|
|
Qt__Key_9 = Qt__Key(0x39)
|
|
Qt__Key_Colon = Qt__Key(0x3a)
|
|
Qt__Key_Semicolon = Qt__Key(0x3b)
|
|
Qt__Key_Less = Qt__Key(0x3c)
|
|
Qt__Key_Equal = Qt__Key(0x3d)
|
|
Qt__Key_Greater = Qt__Key(0x3e)
|
|
Qt__Key_Question = Qt__Key(0x3f)
|
|
Qt__Key_At = Qt__Key(0x40)
|
|
Qt__Key_A = Qt__Key(0x41)
|
|
Qt__Key_B = Qt__Key(0x42)
|
|
Qt__Key_C = Qt__Key(0x43)
|
|
Qt__Key_D = Qt__Key(0x44)
|
|
Qt__Key_E = Qt__Key(0x45)
|
|
Qt__Key_F = Qt__Key(0x46)
|
|
Qt__Key_G = Qt__Key(0x47)
|
|
Qt__Key_H = Qt__Key(0x48)
|
|
Qt__Key_I = Qt__Key(0x49)
|
|
Qt__Key_J = Qt__Key(0x4a)
|
|
Qt__Key_K = Qt__Key(0x4b)
|
|
Qt__Key_L = Qt__Key(0x4c)
|
|
Qt__Key_M = Qt__Key(0x4d)
|
|
Qt__Key_N = Qt__Key(0x4e)
|
|
Qt__Key_O = Qt__Key(0x4f)
|
|
Qt__Key_P = Qt__Key(0x50)
|
|
Qt__Key_Q = Qt__Key(0x51)
|
|
Qt__Key_R = Qt__Key(0x52)
|
|
Qt__Key_S = Qt__Key(0x53)
|
|
Qt__Key_T = Qt__Key(0x54)
|
|
Qt__Key_U = Qt__Key(0x55)
|
|
Qt__Key_V = Qt__Key(0x56)
|
|
Qt__Key_W = Qt__Key(0x57)
|
|
Qt__Key_X = Qt__Key(0x58)
|
|
Qt__Key_Y = Qt__Key(0x59)
|
|
Qt__Key_Z = Qt__Key(0x5a)
|
|
Qt__Key_BracketLeft = Qt__Key(0x5b)
|
|
Qt__Key_Backslash = Qt__Key(0x5c)
|
|
Qt__Key_BracketRight = Qt__Key(0x5d)
|
|
Qt__Key_AsciiCircum = Qt__Key(0x5e)
|
|
Qt__Key_Underscore = Qt__Key(0x5f)
|
|
Qt__Key_QuoteLeft = Qt__Key(0x60)
|
|
Qt__Key_BraceLeft = Qt__Key(0x7b)
|
|
Qt__Key_Bar = Qt__Key(0x7c)
|
|
Qt__Key_BraceRight = Qt__Key(0x7d)
|
|
Qt__Key_AsciiTilde = Qt__Key(0x7e)
|
|
Qt__Key_nobreakspace = Qt__Key(0x0a0)
|
|
Qt__Key_exclamdown = Qt__Key(0x0a1)
|
|
Qt__Key_cent = Qt__Key(0x0a2)
|
|
Qt__Key_sterling = Qt__Key(0x0a3)
|
|
Qt__Key_currency = Qt__Key(0x0a4)
|
|
Qt__Key_yen = Qt__Key(0x0a5)
|
|
Qt__Key_brokenbar = Qt__Key(0x0a6)
|
|
Qt__Key_section = Qt__Key(0x0a7)
|
|
Qt__Key_diaeresis = Qt__Key(0x0a8)
|
|
Qt__Key_copyright = Qt__Key(0x0a9)
|
|
Qt__Key_ordfeminine = Qt__Key(0x0aa)
|
|
Qt__Key_guillemotleft = Qt__Key(0x0ab)
|
|
Qt__Key_notsign = Qt__Key(0x0ac)
|
|
Qt__Key_hyphen = Qt__Key(0x0ad)
|
|
Qt__Key_registered = Qt__Key(0x0ae)
|
|
Qt__Key_macron = Qt__Key(0x0af)
|
|
Qt__Key_degree = Qt__Key(0x0b0)
|
|
Qt__Key_plusminus = Qt__Key(0x0b1)
|
|
Qt__Key_twosuperior = Qt__Key(0x0b2)
|
|
Qt__Key_threesuperior = Qt__Key(0x0b3)
|
|
Qt__Key_acute = Qt__Key(0x0b4)
|
|
Qt__Key_mu = Qt__Key(0x0b5)
|
|
Qt__Key_paragraph = Qt__Key(0x0b6)
|
|
Qt__Key_periodcentered = Qt__Key(0x0b7)
|
|
Qt__Key_cedilla = Qt__Key(0x0b8)
|
|
Qt__Key_onesuperior = Qt__Key(0x0b9)
|
|
Qt__Key_masculine = Qt__Key(0x0ba)
|
|
Qt__Key_guillemotright = Qt__Key(0x0bb)
|
|
Qt__Key_onequarter = Qt__Key(0x0bc)
|
|
Qt__Key_onehalf = Qt__Key(0x0bd)
|
|
Qt__Key_threequarters = Qt__Key(0x0be)
|
|
Qt__Key_questiondown = Qt__Key(0x0bf)
|
|
Qt__Key_Agrave = Qt__Key(0x0c0)
|
|
Qt__Key_Aacute = Qt__Key(0x0c1)
|
|
Qt__Key_Acircumflex = Qt__Key(0x0c2)
|
|
Qt__Key_Atilde = Qt__Key(0x0c3)
|
|
Qt__Key_Adiaeresis = Qt__Key(0x0c4)
|
|
Qt__Key_Aring = Qt__Key(0x0c5)
|
|
Qt__Key_AE = Qt__Key(0x0c6)
|
|
Qt__Key_Ccedilla = Qt__Key(0x0c7)
|
|
Qt__Key_Egrave = Qt__Key(0x0c8)
|
|
Qt__Key_Eacute = Qt__Key(0x0c9)
|
|
Qt__Key_Ecircumflex = Qt__Key(0x0ca)
|
|
Qt__Key_Ediaeresis = Qt__Key(0x0cb)
|
|
Qt__Key_Igrave = Qt__Key(0x0cc)
|
|
Qt__Key_Iacute = Qt__Key(0x0cd)
|
|
Qt__Key_Icircumflex = Qt__Key(0x0ce)
|
|
Qt__Key_Idiaeresis = Qt__Key(0x0cf)
|
|
Qt__Key_ETH = Qt__Key(0x0d0)
|
|
Qt__Key_Ntilde = Qt__Key(0x0d1)
|
|
Qt__Key_Ograve = Qt__Key(0x0d2)
|
|
Qt__Key_Oacute = Qt__Key(0x0d3)
|
|
Qt__Key_Ocircumflex = Qt__Key(0x0d4)
|
|
Qt__Key_Otilde = Qt__Key(0x0d5)
|
|
Qt__Key_Odiaeresis = Qt__Key(0x0d6)
|
|
Qt__Key_multiply = Qt__Key(0x0d7)
|
|
Qt__Key_Ooblique = Qt__Key(0x0d8)
|
|
Qt__Key_Ugrave = Qt__Key(0x0d9)
|
|
Qt__Key_Uacute = Qt__Key(0x0da)
|
|
Qt__Key_Ucircumflex = Qt__Key(0x0db)
|
|
Qt__Key_Udiaeresis = Qt__Key(0x0dc)
|
|
Qt__Key_Yacute = Qt__Key(0x0dd)
|
|
Qt__Key_THORN = Qt__Key(0x0de)
|
|
Qt__Key_ssharp = Qt__Key(0x0df)
|
|
Qt__Key_division = Qt__Key(0x0f7)
|
|
Qt__Key_ydiaeresis = Qt__Key(0x0ff)
|
|
Qt__Key_AltGr = Qt__Key(0x01001103)
|
|
Qt__Key_Multi_key = Qt__Key(0x01001120)
|
|
Qt__Key_Codeinput = Qt__Key(0x01001137)
|
|
Qt__Key_SingleCandidate = Qt__Key(0x0100113c)
|
|
Qt__Key_MultipleCandidate = Qt__Key(0x0100113d)
|
|
Qt__Key_PreviousCandidate = Qt__Key(0x0100113e)
|
|
Qt__Key_Mode_switch = Qt__Key(0x0100117e)
|
|
Qt__Key_Kanji = Qt__Key(0x01001121)
|
|
Qt__Key_Muhenkan = Qt__Key(0x01001122)
|
|
Qt__Key_Henkan = Qt__Key(0x01001123)
|
|
Qt__Key_Romaji = Qt__Key(0x01001124)
|
|
Qt__Key_Hiragana = Qt__Key(0x01001125)
|
|
Qt__Key_Katakana = Qt__Key(0x01001126)
|
|
Qt__Key_Hiragana_Katakana = Qt__Key(0x01001127)
|
|
Qt__Key_Zenkaku = Qt__Key(0x01001128)
|
|
Qt__Key_Hankaku = Qt__Key(0x01001129)
|
|
Qt__Key_Zenkaku_Hankaku = Qt__Key(0x0100112a)
|
|
Qt__Key_Touroku = Qt__Key(0x0100112b)
|
|
Qt__Key_Massyo = Qt__Key(0x0100112c)
|
|
Qt__Key_Kana_Lock = Qt__Key(0x0100112d)
|
|
Qt__Key_Kana_Shift = Qt__Key(0x0100112e)
|
|
Qt__Key_Eisu_Shift = Qt__Key(0x0100112f)
|
|
Qt__Key_Eisu_toggle = Qt__Key(0x01001130)
|
|
Qt__Key_Hangul = Qt__Key(0x01001131)
|
|
Qt__Key_Hangul_Start = Qt__Key(0x01001132)
|
|
Qt__Key_Hangul_End = Qt__Key(0x01001133)
|
|
Qt__Key_Hangul_Hanja = Qt__Key(0x01001134)
|
|
Qt__Key_Hangul_Jamo = Qt__Key(0x01001135)
|
|
Qt__Key_Hangul_Romaja = Qt__Key(0x01001136)
|
|
Qt__Key_Hangul_Jeonja = Qt__Key(0x01001138)
|
|
Qt__Key_Hangul_Banja = Qt__Key(0x01001139)
|
|
Qt__Key_Hangul_PreHanja = Qt__Key(0x0100113a)
|
|
Qt__Key_Hangul_PostHanja = Qt__Key(0x0100113b)
|
|
Qt__Key_Hangul_Special = Qt__Key(0x0100113f)
|
|
Qt__Key_Dead_Grave = Qt__Key(0x01001250)
|
|
Qt__Key_Dead_Acute = Qt__Key(0x01001251)
|
|
Qt__Key_Dead_Circumflex = Qt__Key(0x01001252)
|
|
Qt__Key_Dead_Tilde = Qt__Key(0x01001253)
|
|
Qt__Key_Dead_Macron = Qt__Key(0x01001254)
|
|
Qt__Key_Dead_Breve = Qt__Key(0x01001255)
|
|
Qt__Key_Dead_Abovedot = Qt__Key(0x01001256)
|
|
Qt__Key_Dead_Diaeresis = Qt__Key(0x01001257)
|
|
Qt__Key_Dead_Abovering = Qt__Key(0x01001258)
|
|
Qt__Key_Dead_Doubleacute = Qt__Key(0x01001259)
|
|
Qt__Key_Dead_Caron = Qt__Key(0x0100125a)
|
|
Qt__Key_Dead_Cedilla = Qt__Key(0x0100125b)
|
|
Qt__Key_Dead_Ogonek = Qt__Key(0x0100125c)
|
|
Qt__Key_Dead_Iota = Qt__Key(0x0100125d)
|
|
Qt__Key_Dead_Voiced_Sound = Qt__Key(0x0100125e)
|
|
Qt__Key_Dead_Semivoiced_Sound = Qt__Key(0x0100125f)
|
|
Qt__Key_Dead_Belowdot = Qt__Key(0x01001260)
|
|
Qt__Key_Dead_Hook = Qt__Key(0x01001261)
|
|
Qt__Key_Dead_Horn = Qt__Key(0x01001262)
|
|
Qt__Key_Back = Qt__Key(0x01000061)
|
|
Qt__Key_Forward = Qt__Key(0x01000062)
|
|
Qt__Key_Stop = Qt__Key(0x01000063)
|
|
Qt__Key_Refresh = Qt__Key(0x01000064)
|
|
Qt__Key_VolumeDown = Qt__Key(0x01000070)
|
|
Qt__Key_VolumeMute = Qt__Key(0x01000071)
|
|
Qt__Key_VolumeUp = Qt__Key(0x01000072)
|
|
Qt__Key_BassBoost = Qt__Key(0x01000073)
|
|
Qt__Key_BassUp = Qt__Key(0x01000074)
|
|
Qt__Key_BassDown = Qt__Key(0x01000075)
|
|
Qt__Key_TrebleUp = Qt__Key(0x01000076)
|
|
Qt__Key_TrebleDown = Qt__Key(0x01000077)
|
|
Qt__Key_MediaPlay = Qt__Key(0x01000080)
|
|
Qt__Key_MediaStop = Qt__Key(0x01000081)
|
|
Qt__Key_MediaPrevious = Qt__Key(0x01000082)
|
|
Qt__Key_MediaNext = Qt__Key(0x01000083)
|
|
Qt__Key_MediaRecord = Qt__Key(0x01000084)
|
|
Qt__Key_MediaPause = Qt__Key(0x1000085)
|
|
Qt__Key_MediaTogglePlayPause = Qt__Key(0x1000086)
|
|
Qt__Key_HomePage = Qt__Key(0x01000090)
|
|
Qt__Key_Favorites = Qt__Key(0x01000091)
|
|
Qt__Key_Search = Qt__Key(0x01000092)
|
|
Qt__Key_Standby = Qt__Key(0x01000093)
|
|
Qt__Key_OpenUrl = Qt__Key(0x01000094)
|
|
Qt__Key_LaunchMail = Qt__Key(0x010000a0)
|
|
Qt__Key_LaunchMedia = Qt__Key(0x010000a1)
|
|
Qt__Key_Launch0 = Qt__Key(0x010000a2)
|
|
Qt__Key_Launch1 = Qt__Key(0x010000a3)
|
|
Qt__Key_Launch2 = Qt__Key(0x010000a4)
|
|
Qt__Key_Launch3 = Qt__Key(0x010000a5)
|
|
Qt__Key_Launch4 = Qt__Key(0x010000a6)
|
|
Qt__Key_Launch5 = Qt__Key(0x010000a7)
|
|
Qt__Key_Launch6 = Qt__Key(0x010000a8)
|
|
Qt__Key_Launch7 = Qt__Key(0x010000a9)
|
|
Qt__Key_Launch8 = Qt__Key(0x010000aa)
|
|
Qt__Key_Launch9 = Qt__Key(0x010000ab)
|
|
Qt__Key_LaunchA = Qt__Key(0x010000ac)
|
|
Qt__Key_LaunchB = Qt__Key(0x010000ad)
|
|
Qt__Key_LaunchC = Qt__Key(0x010000ae)
|
|
Qt__Key_LaunchD = Qt__Key(0x010000af)
|
|
Qt__Key_LaunchE = Qt__Key(0x010000b0)
|
|
Qt__Key_LaunchF = Qt__Key(0x010000b1)
|
|
Qt__Key_MonBrightnessUp = Qt__Key(0x010000b2)
|
|
Qt__Key_MonBrightnessDown = Qt__Key(0x010000b3)
|
|
Qt__Key_KeyboardLightOnOff = Qt__Key(0x010000b4)
|
|
Qt__Key_KeyboardBrightnessUp = Qt__Key(0x010000b5)
|
|
Qt__Key_KeyboardBrightnessDown = Qt__Key(0x010000b6)
|
|
Qt__Key_PowerOff = Qt__Key(0x010000b7)
|
|
Qt__Key_WakeUp = Qt__Key(0x010000b8)
|
|
Qt__Key_Eject = Qt__Key(0x010000b9)
|
|
Qt__Key_ScreenSaver = Qt__Key(0x010000ba)
|
|
Qt__Key_WWW = Qt__Key(0x010000bb)
|
|
Qt__Key_Memo = Qt__Key(0x010000bc)
|
|
Qt__Key_LightBulb = Qt__Key(0x010000bd)
|
|
Qt__Key_Shop = Qt__Key(0x010000be)
|
|
Qt__Key_History = Qt__Key(0x010000bf)
|
|
Qt__Key_AddFavorite = Qt__Key(0x010000c0)
|
|
Qt__Key_HotLinks = Qt__Key(0x010000c1)
|
|
Qt__Key_BrightnessAdjust = Qt__Key(0x010000c2)
|
|
Qt__Key_Finance = Qt__Key(0x010000c3)
|
|
Qt__Key_Community = Qt__Key(0x010000c4)
|
|
Qt__Key_AudioRewind = Qt__Key(0x010000c5)
|
|
Qt__Key_BackForward = Qt__Key(0x010000c6)
|
|
Qt__Key_ApplicationLeft = Qt__Key(0x010000c7)
|
|
Qt__Key_ApplicationRight = Qt__Key(0x010000c8)
|
|
Qt__Key_Book = Qt__Key(0x010000c9)
|
|
Qt__Key_CD = Qt__Key(0x010000ca)
|
|
Qt__Key_Calculator = Qt__Key(0x010000cb)
|
|
Qt__Key_ToDoList = Qt__Key(0x010000cc)
|
|
Qt__Key_ClearGrab = Qt__Key(0x010000cd)
|
|
Qt__Key_Close = Qt__Key(0x010000ce)
|
|
Qt__Key_Copy = Qt__Key(0x010000cf)
|
|
Qt__Key_Cut = Qt__Key(0x010000d0)
|
|
Qt__Key_Display = Qt__Key(0x010000d1)
|
|
Qt__Key_DOS = Qt__Key(0x010000d2)
|
|
Qt__Key_Documents = Qt__Key(0x010000d3)
|
|
Qt__Key_Excel = Qt__Key(0x010000d4)
|
|
Qt__Key_Explorer = Qt__Key(0x010000d5)
|
|
Qt__Key_Game = Qt__Key(0x010000d6)
|
|
Qt__Key_Go = Qt__Key(0x010000d7)
|
|
Qt__Key_iTouch = Qt__Key(0x010000d8)
|
|
Qt__Key_LogOff = Qt__Key(0x010000d9)
|
|
Qt__Key_Market = Qt__Key(0x010000da)
|
|
Qt__Key_Meeting = Qt__Key(0x010000db)
|
|
Qt__Key_MenuKB = Qt__Key(0x010000dc)
|
|
Qt__Key_MenuPB = Qt__Key(0x010000dd)
|
|
Qt__Key_MySites = Qt__Key(0x010000de)
|
|
Qt__Key_News = Qt__Key(0x010000df)
|
|
Qt__Key_OfficeHome = Qt__Key(0x010000e0)
|
|
Qt__Key_Option = Qt__Key(0x010000e1)
|
|
Qt__Key_Paste = Qt__Key(0x010000e2)
|
|
Qt__Key_Phone = Qt__Key(0x010000e3)
|
|
Qt__Key_Calendar = Qt__Key(0x010000e4)
|
|
Qt__Key_Reply = Qt__Key(0x010000e5)
|
|
Qt__Key_Reload = Qt__Key(0x010000e6)
|
|
Qt__Key_RotateWindows = Qt__Key(0x010000e7)
|
|
Qt__Key_RotationPB = Qt__Key(0x010000e8)
|
|
Qt__Key_RotationKB = Qt__Key(0x010000e9)
|
|
Qt__Key_Save = Qt__Key(0x010000ea)
|
|
Qt__Key_Send = Qt__Key(0x010000eb)
|
|
Qt__Key_Spell = Qt__Key(0x010000ec)
|
|
Qt__Key_SplitScreen = Qt__Key(0x010000ed)
|
|
Qt__Key_Support = Qt__Key(0x010000ee)
|
|
Qt__Key_TaskPane = Qt__Key(0x010000ef)
|
|
Qt__Key_Terminal = Qt__Key(0x010000f0)
|
|
Qt__Key_Tools = Qt__Key(0x010000f1)
|
|
Qt__Key_Travel = Qt__Key(0x010000f2)
|
|
Qt__Key_Video = Qt__Key(0x010000f3)
|
|
Qt__Key_Word = Qt__Key(0x010000f4)
|
|
Qt__Key_Xfer = Qt__Key(0x010000f5)
|
|
Qt__Key_ZoomIn = Qt__Key(0x010000f6)
|
|
Qt__Key_ZoomOut = Qt__Key(0x010000f7)
|
|
Qt__Key_Away = Qt__Key(0x010000f8)
|
|
Qt__Key_Messenger = Qt__Key(0x010000f9)
|
|
Qt__Key_WebCam = Qt__Key(0x010000fa)
|
|
Qt__Key_MailForward = Qt__Key(0x010000fb)
|
|
Qt__Key_Pictures = Qt__Key(0x010000fc)
|
|
Qt__Key_Music = Qt__Key(0x010000fd)
|
|
Qt__Key_Battery = Qt__Key(0x010000fe)
|
|
Qt__Key_Bluetooth = Qt__Key(0x010000ff)
|
|
Qt__Key_WLAN = Qt__Key(0x01000100)
|
|
Qt__Key_UWB = Qt__Key(0x01000101)
|
|
Qt__Key_AudioForward = Qt__Key(0x01000102)
|
|
Qt__Key_AudioRepeat = Qt__Key(0x01000103)
|
|
Qt__Key_AudioRandomPlay = Qt__Key(0x01000104)
|
|
Qt__Key_Subtitle = Qt__Key(0x01000105)
|
|
Qt__Key_AudioCycleTrack = Qt__Key(0x01000106)
|
|
Qt__Key_Time = Qt__Key(0x01000107)
|
|
Qt__Key_Hibernate = Qt__Key(0x01000108)
|
|
Qt__Key_View = Qt__Key(0x01000109)
|
|
Qt__Key_TopMenu = Qt__Key(0x0100010a)
|
|
Qt__Key_PowerDown = Qt__Key(0x0100010b)
|
|
Qt__Key_Suspend = Qt__Key(0x0100010c)
|
|
Qt__Key_ContrastAdjust = Qt__Key(0x0100010d)
|
|
Qt__Key_LaunchG = Qt__Key(0x0100010e)
|
|
Qt__Key_LaunchH = Qt__Key(0x0100010f)
|
|
Qt__Key_TouchpadToggle = Qt__Key(0x01000110)
|
|
Qt__Key_TouchpadOn = Qt__Key(0x01000111)
|
|
Qt__Key_TouchpadOff = Qt__Key(0x01000112)
|
|
Qt__Key_MicMute = Qt__Key(0x01000113)
|
|
Qt__Key_Red = Qt__Key(0x01000114)
|
|
Qt__Key_Green = Qt__Key(0x01000115)
|
|
Qt__Key_Yellow = Qt__Key(0x01000116)
|
|
Qt__Key_Blue = Qt__Key(0x01000117)
|
|
Qt__Key_ChannelUp = Qt__Key(0x01000118)
|
|
Qt__Key_ChannelDown = Qt__Key(0x01000119)
|
|
Qt__Key_Guide = Qt__Key(0x0100011a)
|
|
Qt__Key_Info = Qt__Key(0x0100011b)
|
|
Qt__Key_Settings = Qt__Key(0x0100011c)
|
|
Qt__Key_MicVolumeUp = Qt__Key(0x0100011d)
|
|
Qt__Key_MicVolumeDown = Qt__Key(0x0100011e)
|
|
Qt__Key_New = Qt__Key(0x01000120)
|
|
Qt__Key_Open = Qt__Key(0x01000121)
|
|
Qt__Key_Find = Qt__Key(0x01000122)
|
|
Qt__Key_Undo = Qt__Key(0x01000123)
|
|
Qt__Key_Redo = Qt__Key(0x01000124)
|
|
Qt__Key_MediaLast = Qt__Key(0x0100ffff)
|
|
Qt__Key_Select = Qt__Key(0x01010000)
|
|
Qt__Key_Yes = Qt__Key(0x01010001)
|
|
Qt__Key_No = Qt__Key(0x01010002)
|
|
Qt__Key_Cancel = Qt__Key(0x01020001)
|
|
Qt__Key_Printer = Qt__Key(0x01020002)
|
|
Qt__Key_Execute = Qt__Key(0x01020003)
|
|
Qt__Key_Sleep = Qt__Key(0x01020004)
|
|
Qt__Key_Play = Qt__Key(0x01020005)
|
|
Qt__Key_Zoom = Qt__Key(0x01020006)
|
|
Qt__Key_Exit = Qt__Key(0x0102000a)
|
|
Qt__Key_Context1 = Qt__Key(0x01100000)
|
|
Qt__Key_Context2 = Qt__Key(0x01100001)
|
|
Qt__Key_Context3 = Qt__Key(0x01100002)
|
|
Qt__Key_Context4 = Qt__Key(0x01100003)
|
|
Qt__Key_Call = Qt__Key(0x01100004)
|
|
Qt__Key_Hangup = Qt__Key(0x01100005)
|
|
Qt__Key_Flip = Qt__Key(0x01100006)
|
|
Qt__Key_ToggleCallHangup = Qt__Key(0x01100007)
|
|
Qt__Key_VoiceDial = Qt__Key(0x01100008)
|
|
Qt__Key_LastNumberRedial = Qt__Key(0x01100009)
|
|
Qt__Key_Camera = Qt__Key(0x01100020)
|
|
Qt__Key_CameraFocus = Qt__Key(0x01100021)
|
|
Qt__Key_unknown = Qt__Key(0x01ffffff)
|
|
)
|
|
|
|
//Qt::KeyboardModifier
|
|
type Qt__KeyboardModifier int64
|
|
|
|
const (
|
|
Qt__NoModifier = Qt__KeyboardModifier(0x00000000)
|
|
Qt__ShiftModifier = Qt__KeyboardModifier(0x02000000)
|
|
Qt__ControlModifier = Qt__KeyboardModifier(0x04000000)
|
|
Qt__AltModifier = Qt__KeyboardModifier(0x08000000)
|
|
Qt__MetaModifier = Qt__KeyboardModifier(0x10000000)
|
|
Qt__KeypadModifier = Qt__KeyboardModifier(0x20000000)
|
|
Qt__GroupSwitchModifier = Qt__KeyboardModifier(0x40000000)
|
|
Qt__KeyboardModifierMask = Qt__KeyboardModifier(0xfe000000)
|
|
)
|
|
|
|
//Qt::LayoutDirection
|
|
type Qt__LayoutDirection int64
|
|
|
|
const (
|
|
Qt__LeftToRight = Qt__LayoutDirection(0)
|
|
Qt__RightToLeft = Qt__LayoutDirection(1)
|
|
Qt__LayoutDirectionAuto = Qt__LayoutDirection(2)
|
|
)
|
|
|
|
//Qt::MaskMode
|
|
type Qt__MaskMode int64
|
|
|
|
const (
|
|
Qt__MaskInColor = Qt__MaskMode(0)
|
|
Qt__MaskOutColor = Qt__MaskMode(1)
|
|
)
|
|
|
|
//Qt::MatchFlag
|
|
type Qt__MatchFlag int64
|
|
|
|
const (
|
|
Qt__MatchExactly = Qt__MatchFlag(0)
|
|
Qt__MatchContains = Qt__MatchFlag(1)
|
|
Qt__MatchStartsWith = Qt__MatchFlag(2)
|
|
Qt__MatchEndsWith = Qt__MatchFlag(3)
|
|
Qt__MatchRegExp = Qt__MatchFlag(4)
|
|
Qt__MatchWildcard = Qt__MatchFlag(5)
|
|
Qt__MatchFixedString = Qt__MatchFlag(8)
|
|
Qt__MatchCaseSensitive = Qt__MatchFlag(16)
|
|
Qt__MatchWrap = Qt__MatchFlag(32)
|
|
Qt__MatchRecursive = Qt__MatchFlag(64)
|
|
)
|
|
|
|
//Qt::Modifier
|
|
type Qt__Modifier int64
|
|
|
|
const (
|
|
Qt__META = Qt__Modifier(Qt__MetaModifier)
|
|
Qt__SHIFT = Qt__Modifier(Qt__ShiftModifier)
|
|
Qt__CTRL = Qt__Modifier(Qt__ControlModifier)
|
|
Qt__ALT = Qt__Modifier(Qt__AltModifier)
|
|
Qt__MODIFIER_MASK = Qt__Modifier(Qt__KeyboardModifierMask)
|
|
Qt__UNICODE_ACCEL = Qt__Modifier(0x00000000)
|
|
)
|
|
|
|
//Qt::MouseButton
|
|
type Qt__MouseButton int64
|
|
|
|
const (
|
|
Qt__NoButton = Qt__MouseButton(0x00000000)
|
|
Qt__LeftButton = Qt__MouseButton(0x00000001)
|
|
Qt__RightButton = Qt__MouseButton(0x00000002)
|
|
Qt__MidButton = Qt__MouseButton(0x00000004)
|
|
Qt__MiddleButton = Qt__MouseButton(Qt__MidButton)
|
|
Qt__BackButton = Qt__MouseButton(0x00000008)
|
|
Qt__XButton1 = Qt__MouseButton(Qt__BackButton)
|
|
Qt__ExtraButton1 = Qt__MouseButton(Qt__XButton1)
|
|
Qt__ForwardButton = Qt__MouseButton(0x00000010)
|
|
Qt__XButton2 = Qt__MouseButton(Qt__ForwardButton)
|
|
Qt__ExtraButton2 = Qt__MouseButton(Qt__ForwardButton)
|
|
Qt__TaskButton = Qt__MouseButton(0x00000020)
|
|
Qt__ExtraButton3 = Qt__MouseButton(Qt__TaskButton)
|
|
Qt__ExtraButton4 = Qt__MouseButton(0x00000040)
|
|
Qt__ExtraButton5 = Qt__MouseButton(0x00000080)
|
|
Qt__ExtraButton6 = Qt__MouseButton(0x00000100)
|
|
Qt__ExtraButton7 = Qt__MouseButton(0x00000200)
|
|
Qt__ExtraButton8 = Qt__MouseButton(0x00000400)
|
|
Qt__ExtraButton9 = Qt__MouseButton(0x00000800)
|
|
Qt__ExtraButton10 = Qt__MouseButton(0x00001000)
|
|
Qt__ExtraButton11 = Qt__MouseButton(0x00002000)
|
|
Qt__ExtraButton12 = Qt__MouseButton(0x00004000)
|
|
Qt__ExtraButton13 = Qt__MouseButton(0x00008000)
|
|
Qt__ExtraButton14 = Qt__MouseButton(0x00010000)
|
|
Qt__ExtraButton15 = Qt__MouseButton(0x00020000)
|
|
Qt__ExtraButton16 = Qt__MouseButton(0x00040000)
|
|
Qt__ExtraButton17 = Qt__MouseButton(0x00080000)
|
|
Qt__ExtraButton18 = Qt__MouseButton(0x00100000)
|
|
Qt__ExtraButton19 = Qt__MouseButton(0x00200000)
|
|
Qt__ExtraButton20 = Qt__MouseButton(0x00400000)
|
|
Qt__ExtraButton21 = Qt__MouseButton(0x00800000)
|
|
Qt__ExtraButton22 = Qt__MouseButton(0x01000000)
|
|
Qt__ExtraButton23 = Qt__MouseButton(0x02000000)
|
|
Qt__ExtraButton24 = Qt__MouseButton(0x04000000)
|
|
Qt__AllButtons = Qt__MouseButton(0x07ffffff)
|
|
Qt__MaxMouseButton = Qt__MouseButton(Qt__ExtraButton24)
|
|
Qt__MouseButtonMask = Qt__MouseButton(0xffffffff)
|
|
)
|
|
|
|
//Qt::MouseEventFlag
|
|
type Qt__MouseEventFlag int64
|
|
|
|
const (
|
|
Qt__MouseEventCreatedDoubleClick = Qt__MouseEventFlag(0x01)
|
|
Qt__MouseEventFlagMask = Qt__MouseEventFlag(0xFF)
|
|
)
|
|
|
|
//Qt::MouseEventSource
|
|
type Qt__MouseEventSource int64
|
|
|
|
const (
|
|
Qt__MouseEventNotSynthesized = Qt__MouseEventSource(0)
|
|
Qt__MouseEventSynthesizedBySystem = Qt__MouseEventSource(1)
|
|
Qt__MouseEventSynthesizedByQt = Qt__MouseEventSource(2)
|
|
Qt__MouseEventSynthesizedByApplication = Qt__MouseEventSource(3)
|
|
)
|
|
|
|
//Qt::NativeGestureType
|
|
type Qt__NativeGestureType int64
|
|
|
|
const (
|
|
Qt__BeginNativeGesture = Qt__NativeGestureType(0)
|
|
Qt__EndNativeGesture = Qt__NativeGestureType(1)
|
|
Qt__PanNativeGesture = Qt__NativeGestureType(2)
|
|
Qt__ZoomNativeGesture = Qt__NativeGestureType(3)
|
|
Qt__SmartZoomNativeGesture = Qt__NativeGestureType(4)
|
|
Qt__RotateNativeGesture = Qt__NativeGestureType(5)
|
|
Qt__SwipeNativeGesture = Qt__NativeGestureType(6)
|
|
)
|
|
|
|
//Qt::NavigationMode
|
|
type Qt__NavigationMode int64
|
|
|
|
const (
|
|
Qt__NavigationModeNone = Qt__NavigationMode(0)
|
|
Qt__NavigationModeKeypadTabOrder = Qt__NavigationMode(1)
|
|
Qt__NavigationModeKeypadDirectional = Qt__NavigationMode(2)
|
|
Qt__NavigationModeCursorAuto = Qt__NavigationMode(3)
|
|
Qt__NavigationModeCursorForceVisible = Qt__NavigationMode(4)
|
|
)
|
|
|
|
//Qt::Orientation
|
|
type Qt__Orientation int64
|
|
|
|
const (
|
|
Qt__Horizontal = Qt__Orientation(0x1)
|
|
Qt__Vertical = Qt__Orientation(0x2)
|
|
)
|
|
|
|
//Qt::PenCapStyle
|
|
type Qt__PenCapStyle int64
|
|
|
|
var (
|
|
Qt__FlatCap = Qt__PenCapStyle(0x00)
|
|
Qt__SquareCap = Qt__PenCapStyle(0x10)
|
|
Qt__RoundCap = Qt__PenCapStyle(0x20)
|
|
Qt__MPenCapStyle = Qt__PenCapStyle(0x30)
|
|
)
|
|
|
|
//Qt::PenJoinStyle
|
|
type Qt__PenJoinStyle int64
|
|
|
|
var (
|
|
Qt__MiterJoin = Qt__PenJoinStyle(0x00)
|
|
Qt__BevelJoin = Qt__PenJoinStyle(0x40)
|
|
Qt__RoundJoin = Qt__PenJoinStyle(0x80)
|
|
Qt__SvgMiterJoin = Qt__PenJoinStyle(0x100)
|
|
Qt__MPenJoinStyle = Qt__PenJoinStyle(0x1c0)
|
|
)
|
|
|
|
//Qt::PenStyle
|
|
type Qt__PenStyle int64
|
|
|
|
var (
|
|
Qt__NoPen = Qt__PenStyle(0)
|
|
Qt__SolidLine = Qt__PenStyle(1)
|
|
Qt__DashLine = Qt__PenStyle(2)
|
|
Qt__DotLine = Qt__PenStyle(3)
|
|
Qt__DashDotLine = Qt__PenStyle(4)
|
|
Qt__DashDotDotLine = Qt__PenStyle(5)
|
|
Qt__CustomDashLine = Qt__PenStyle(6)
|
|
Qt__MPenStyle = Qt__PenStyle(0x0f)
|
|
)
|
|
|
|
//Qt::ScreenOrientation
|
|
type Qt__ScreenOrientation int64
|
|
|
|
const (
|
|
Qt__PrimaryOrientation = Qt__ScreenOrientation(0x00000000)
|
|
Qt__PortraitOrientation = Qt__ScreenOrientation(0x00000001)
|
|
Qt__LandscapeOrientation = Qt__ScreenOrientation(0x00000002)
|
|
Qt__InvertedPortraitOrientation = Qt__ScreenOrientation(0x00000004)
|
|
Qt__InvertedLandscapeOrientation = Qt__ScreenOrientation(0x00000008)
|
|
)
|
|
|
|
//Qt::ScrollBarPolicy
|
|
type Qt__ScrollBarPolicy int64
|
|
|
|
const (
|
|
Qt__ScrollBarAsNeeded = Qt__ScrollBarPolicy(0)
|
|
Qt__ScrollBarAlwaysOff = Qt__ScrollBarPolicy(1)
|
|
Qt__ScrollBarAlwaysOn = Qt__ScrollBarPolicy(2)
|
|
)
|
|
|
|
//Qt::ScrollPhase
|
|
type Qt__ScrollPhase int64
|
|
|
|
const (
|
|
Qt__ScrollBegin = Qt__ScrollPhase(1)
|
|
Qt__ScrollUpdate = Qt__ScrollPhase(2)
|
|
Qt__ScrollEnd = Qt__ScrollPhase(3)
|
|
)
|
|
|
|
//Qt::ShortcutContext
|
|
type Qt__ShortcutContext int64
|
|
|
|
const (
|
|
Qt__WidgetShortcut = Qt__ShortcutContext(0)
|
|
Qt__WindowShortcut = Qt__ShortcutContext(1)
|
|
Qt__ApplicationShortcut = Qt__ShortcutContext(2)
|
|
Qt__WidgetWithChildrenShortcut = Qt__ShortcutContext(3)
|
|
)
|
|
|
|
//Qt::SizeHint
|
|
type Qt__SizeHint int64
|
|
|
|
const (
|
|
Qt__MinimumSize = Qt__SizeHint(0)
|
|
Qt__PreferredSize = Qt__SizeHint(1)
|
|
Qt__MaximumSize = Qt__SizeHint(2)
|
|
Qt__MinimumDescent = Qt__SizeHint(3)
|
|
Qt__NSizeHints = Qt__SizeHint(4)
|
|
)
|
|
|
|
//Qt::SizeMode
|
|
type Qt__SizeMode int64
|
|
|
|
const (
|
|
Qt__AbsoluteSize = Qt__SizeMode(0)
|
|
Qt__RelativeSize = Qt__SizeMode(1)
|
|
)
|
|
|
|
//Qt::SortOrder
|
|
type Qt__SortOrder int64
|
|
|
|
const (
|
|
Qt__AscendingOrder = Qt__SortOrder(0)
|
|
Qt__DescendingOrder = Qt__SortOrder(1)
|
|
)
|
|
|
|
//Qt::TabFocusBehavior
|
|
type Qt__TabFocusBehavior int64
|
|
|
|
const (
|
|
Qt__NoTabFocus = Qt__TabFocusBehavior(0x00)
|
|
Qt__TabFocusTextControls = Qt__TabFocusBehavior(0x01)
|
|
Qt__TabFocusListControls = Qt__TabFocusBehavior(0x02)
|
|
Qt__TabFocusAllControls = Qt__TabFocusBehavior(0xff)
|
|
)
|
|
|
|
//Qt::TextElideMode
|
|
type Qt__TextElideMode int64
|
|
|
|
const (
|
|
Qt__ElideLeft = Qt__TextElideMode(0)
|
|
Qt__ElideRight = Qt__TextElideMode(1)
|
|
Qt__ElideMiddle = Qt__TextElideMode(2)
|
|
Qt__ElideNone = Qt__TextElideMode(3)
|
|
)
|
|
|
|
//Qt::TextFlag
|
|
type Qt__TextFlag int64
|
|
|
|
const (
|
|
Qt__TextSingleLine = Qt__TextFlag(0x0100)
|
|
Qt__TextDontClip = Qt__TextFlag(0x0200)
|
|
Qt__TextExpandTabs = Qt__TextFlag(0x0400)
|
|
Qt__TextShowMnemonic = Qt__TextFlag(0x0800)
|
|
Qt__TextWordWrap = Qt__TextFlag(0x1000)
|
|
Qt__TextWrapAnywhere = Qt__TextFlag(0x2000)
|
|
Qt__TextDontPrint = Qt__TextFlag(0x4000)
|
|
Qt__TextIncludeTrailingSpaces = Qt__TextFlag(0x08000000)
|
|
Qt__TextHideMnemonic = Qt__TextFlag(0x8000)
|
|
Qt__TextJustificationForced = Qt__TextFlag(0x10000)
|
|
Qt__TextForceLeftToRight = Qt__TextFlag(0x20000)
|
|
Qt__TextForceRightToLeft = Qt__TextFlag(0x40000)
|
|
Qt__TextLongestVariant = Qt__TextFlag(0x80000)
|
|
Qt__TextBypassShaping = Qt__TextFlag(0x100000)
|
|
)
|
|
|
|
//Qt::TextFormat
|
|
type Qt__TextFormat int64
|
|
|
|
const (
|
|
Qt__PlainText = Qt__TextFormat(0)
|
|
Qt__RichText = Qt__TextFormat(1)
|
|
Qt__AutoText = Qt__TextFormat(2)
|
|
)
|
|
|
|
//Qt::TextInteractionFlag
|
|
type Qt__TextInteractionFlag int64
|
|
|
|
const (
|
|
Qt__NoTextInteraction = Qt__TextInteractionFlag(0)
|
|
Qt__TextSelectableByMouse = Qt__TextInteractionFlag(1)
|
|
Qt__TextSelectableByKeyboard = Qt__TextInteractionFlag(2)
|
|
Qt__LinksAccessibleByMouse = Qt__TextInteractionFlag(4)
|
|
Qt__LinksAccessibleByKeyboard = Qt__TextInteractionFlag(8)
|
|
Qt__TextEditable = Qt__TextInteractionFlag(16)
|
|
Qt__TextEditorInteraction = Qt__TextInteractionFlag(Qt__TextSelectableByMouse | Qt__TextSelectableByKeyboard | Qt__TextEditable)
|
|
Qt__TextBrowserInteraction = Qt__TextInteractionFlag(Qt__TextSelectableByMouse | Qt__LinksAccessibleByMouse | Qt__LinksAccessibleByKeyboard)
|
|
)
|
|
|
|
//Qt::TileRule
|
|
type Qt__TileRule int64
|
|
|
|
const (
|
|
Qt__StretchTile = Qt__TileRule(0)
|
|
Qt__RepeatTile = Qt__TileRule(1)
|
|
Qt__RoundTile = Qt__TileRule(2)
|
|
)
|
|
|
|
//Qt::TimeSpec
|
|
type Qt__TimeSpec int64
|
|
|
|
const (
|
|
Qt__LocalTime = Qt__TimeSpec(0)
|
|
Qt__UTC = Qt__TimeSpec(1)
|
|
Qt__OffsetFromUTC = Qt__TimeSpec(2)
|
|
Qt__TimeZone = Qt__TimeSpec(3)
|
|
)
|
|
|
|
//Qt::TimerType
|
|
type Qt__TimerType int64
|
|
|
|
const (
|
|
Qt__PreciseTimer = Qt__TimerType(0)
|
|
Qt__CoarseTimer = Qt__TimerType(1)
|
|
Qt__VeryCoarseTimer = Qt__TimerType(2)
|
|
)
|
|
|
|
//Qt::ToolBarArea
|
|
type Qt__ToolBarArea int64
|
|
|
|
const (
|
|
Qt__LeftToolBarArea = Qt__ToolBarArea(0x1)
|
|
Qt__RightToolBarArea = Qt__ToolBarArea(0x2)
|
|
Qt__TopToolBarArea = Qt__ToolBarArea(0x4)
|
|
Qt__BottomToolBarArea = Qt__ToolBarArea(0x8)
|
|
Qt__ToolBarArea_Mask = Qt__ToolBarArea(0xf)
|
|
Qt__AllToolBarAreas = Qt__ToolBarArea(Qt__ToolBarArea_Mask)
|
|
Qt__NoToolBarArea = Qt__ToolBarArea(0)
|
|
)
|
|
|
|
//Qt::ToolButtonStyle
|
|
type Qt__ToolButtonStyle int64
|
|
|
|
var (
|
|
Qt__ToolButtonIconOnly = Qt__ToolButtonStyle(0)
|
|
Qt__ToolButtonTextOnly = Qt__ToolButtonStyle(1)
|
|
Qt__ToolButtonTextBesideIcon = Qt__ToolButtonStyle(2)
|
|
Qt__ToolButtonTextUnderIcon = Qt__ToolButtonStyle(3)
|
|
Qt__ToolButtonFollowStyle = Qt__ToolButtonStyle(4)
|
|
)
|
|
|
|
//Qt::TouchPointState
|
|
type Qt__TouchPointState int64
|
|
|
|
const (
|
|
Qt__TouchPointPressed = Qt__TouchPointState(0x01)
|
|
Qt__TouchPointMoved = Qt__TouchPointState(0x02)
|
|
Qt__TouchPointStationary = Qt__TouchPointState(0x04)
|
|
Qt__TouchPointReleased = Qt__TouchPointState(0x08)
|
|
)
|
|
|
|
//Qt::TransformationMode
|
|
type Qt__TransformationMode int64
|
|
|
|
const (
|
|
Qt__FastTransformation = Qt__TransformationMode(0)
|
|
Qt__SmoothTransformation = Qt__TransformationMode(1)
|
|
)
|
|
|
|
//Qt::UIEffect
|
|
type Qt__UIEffect int64
|
|
|
|
const (
|
|
Qt__UI_General = Qt__UIEffect(0)
|
|
Qt__UI_AnimateMenu = Qt__UIEffect(1)
|
|
Qt__UI_FadeMenu = Qt__UIEffect(2)
|
|
Qt__UI_AnimateCombo = Qt__UIEffect(3)
|
|
Qt__UI_AnimateTooltip = Qt__UIEffect(4)
|
|
Qt__UI_FadeTooltip = Qt__UIEffect(5)
|
|
Qt__UI_AnimateToolBox = Qt__UIEffect(6)
|
|
)
|
|
|
|
//Qt::WhiteSpaceMode
|
|
type Qt__WhiteSpaceMode int64
|
|
|
|
const (
|
|
Qt__WhiteSpaceNormal = Qt__WhiteSpaceMode(0)
|
|
Qt__WhiteSpacePre = Qt__WhiteSpaceMode(1)
|
|
Qt__WhiteSpaceNoWrap = Qt__WhiteSpaceMode(2)
|
|
Qt__WhiteSpaceModeUndefined = Qt__WhiteSpaceMode(-1)
|
|
)
|
|
|
|
//Qt::WidgetAttribute
|
|
type Qt__WidgetAttribute int64
|
|
|
|
const (
|
|
Qt__WA_Disabled = Qt__WidgetAttribute(0)
|
|
Qt__WA_UnderMouse = Qt__WidgetAttribute(1)
|
|
Qt__WA_MouseTracking = Qt__WidgetAttribute(2)
|
|
Qt__WA_ContentsPropagated = Qt__WidgetAttribute(3)
|
|
Qt__WA_OpaquePaintEvent = Qt__WidgetAttribute(4)
|
|
Qt__WA_NoBackground = Qt__WidgetAttribute(Qt__WA_OpaquePaintEvent)
|
|
Qt__WA_StaticContents = Qt__WidgetAttribute(5)
|
|
Qt__WA_LaidOut = Qt__WidgetAttribute(7)
|
|
Qt__WA_PaintOnScreen = Qt__WidgetAttribute(8)
|
|
Qt__WA_NoSystemBackground = Qt__WidgetAttribute(9)
|
|
Qt__WA_UpdatesDisabled = Qt__WidgetAttribute(10)
|
|
Qt__WA_Mapped = Qt__WidgetAttribute(11)
|
|
Qt__WA_MacNoClickThrough = Qt__WidgetAttribute(12)
|
|
Qt__WA_InputMethodEnabled = Qt__WidgetAttribute(14)
|
|
Qt__WA_WState_Visible = Qt__WidgetAttribute(15)
|
|
Qt__WA_WState_Hidden = Qt__WidgetAttribute(16)
|
|
Qt__WA_ForceDisabled = Qt__WidgetAttribute(32)
|
|
Qt__WA_KeyCompression = Qt__WidgetAttribute(33)
|
|
Qt__WA_PendingMoveEvent = Qt__WidgetAttribute(34)
|
|
Qt__WA_PendingResizeEvent = Qt__WidgetAttribute(35)
|
|
Qt__WA_SetPalette = Qt__WidgetAttribute(36)
|
|
Qt__WA_SetFont = Qt__WidgetAttribute(37)
|
|
Qt__WA_SetCursor = Qt__WidgetAttribute(38)
|
|
Qt__WA_NoChildEventsFromChildren = Qt__WidgetAttribute(39)
|
|
Qt__WA_WindowModified = Qt__WidgetAttribute(41)
|
|
Qt__WA_Resized = Qt__WidgetAttribute(42)
|
|
Qt__WA_Moved = Qt__WidgetAttribute(43)
|
|
Qt__WA_PendingUpdate = Qt__WidgetAttribute(44)
|
|
Qt__WA_InvalidSize = Qt__WidgetAttribute(45)
|
|
Qt__WA_MacBrushedMetal = Qt__WidgetAttribute(46)
|
|
Qt__WA_MacMetalStyle = Qt__WidgetAttribute(Qt__WA_MacBrushedMetal)
|
|
Qt__WA_CustomWhatsThis = Qt__WidgetAttribute(47)
|
|
Qt__WA_LayoutOnEntireRect = Qt__WidgetAttribute(48)
|
|
Qt__WA_OutsideWSRange = Qt__WidgetAttribute(49)
|
|
Qt__WA_GrabbedShortcut = Qt__WidgetAttribute(50)
|
|
Qt__WA_TransparentForMouseEvents = Qt__WidgetAttribute(51)
|
|
Qt__WA_PaintUnclipped = Qt__WidgetAttribute(52)
|
|
Qt__WA_SetWindowIcon = Qt__WidgetAttribute(53)
|
|
Qt__WA_NoMouseReplay = Qt__WidgetAttribute(54)
|
|
Qt__WA_DeleteOnClose = Qt__WidgetAttribute(55)
|
|
Qt__WA_RightToLeft = Qt__WidgetAttribute(56)
|
|
Qt__WA_SetLayoutDirection = Qt__WidgetAttribute(57)
|
|
Qt__WA_NoChildEventsForParent = Qt__WidgetAttribute(58)
|
|
Qt__WA_ForceUpdatesDisabled = Qt__WidgetAttribute(59)
|
|
Qt__WA_WState_Created = Qt__WidgetAttribute(60)
|
|
Qt__WA_WState_CompressKeys = Qt__WidgetAttribute(61)
|
|
Qt__WA_WState_InPaintEvent = Qt__WidgetAttribute(62)
|
|
Qt__WA_WState_Reparented = Qt__WidgetAttribute(63)
|
|
Qt__WA_WState_ConfigPending = Qt__WidgetAttribute(64)
|
|
Qt__WA_WState_Polished = Qt__WidgetAttribute(66)
|
|
Qt__WA_WState_DND = Qt__WidgetAttribute(67)
|
|
Qt__WA_WState_OwnSizePolicy = Qt__WidgetAttribute(68)
|
|
Qt__WA_WState_ExplicitShowHide = Qt__WidgetAttribute(69)
|
|
Qt__WA_ShowModal = Qt__WidgetAttribute(70)
|
|
Qt__WA_MouseNoMask = Qt__WidgetAttribute(71)
|
|
Qt__WA_GroupLeader = Qt__WidgetAttribute(72)
|
|
Qt__WA_NoMousePropagation = Qt__WidgetAttribute(73)
|
|
Qt__WA_Hover = Qt__WidgetAttribute(74)
|
|
Qt__WA_InputMethodTransparent = Qt__WidgetAttribute(75)
|
|
Qt__WA_QuitOnClose = Qt__WidgetAttribute(76)
|
|
Qt__WA_KeyboardFocusChange = Qt__WidgetAttribute(77)
|
|
Qt__WA_AcceptDrops = Qt__WidgetAttribute(78)
|
|
Qt__WA_DropSiteRegistered = Qt__WidgetAttribute(79)
|
|
Qt__WA_ForceAcceptDrops = Qt__WidgetAttribute(Qt__WA_DropSiteRegistered)
|
|
Qt__WA_WindowPropagation = Qt__WidgetAttribute(80)
|
|
Qt__WA_NoX11EventCompression = Qt__WidgetAttribute(81)
|
|
Qt__WA_TintedBackground = Qt__WidgetAttribute(82)
|
|
Qt__WA_X11OpenGLOverlay = Qt__WidgetAttribute(83)
|
|
Qt__WA_AlwaysShowToolTips = Qt__WidgetAttribute(84)
|
|
Qt__WA_MacOpaqueSizeGrip = Qt__WidgetAttribute(85)
|
|
Qt__WA_SetStyle = Qt__WidgetAttribute(86)
|
|
Qt__WA_SetLocale = Qt__WidgetAttribute(87)
|
|
Qt__WA_MacShowFocusRect = Qt__WidgetAttribute(88)
|
|
Qt__WA_MacNormalSize = Qt__WidgetAttribute(89)
|
|
Qt__WA_MacSmallSize = Qt__WidgetAttribute(90)
|
|
Qt__WA_MacMiniSize = Qt__WidgetAttribute(91)
|
|
Qt__WA_LayoutUsesWidgetRect = Qt__WidgetAttribute(92)
|
|
Qt__WA_StyledBackground = Qt__WidgetAttribute(93)
|
|
Qt__WA_MSWindowsUseDirect3D = Qt__WidgetAttribute(94)
|
|
Qt__WA_CanHostQMdiSubWindowTitleBar = Qt__WidgetAttribute(95)
|
|
Qt__WA_MacAlwaysShowToolWindow = Qt__WidgetAttribute(96)
|
|
Qt__WA_StyleSheet = Qt__WidgetAttribute(97)
|
|
Qt__WA_ShowWithoutActivating = Qt__WidgetAttribute(98)
|
|
Qt__WA_X11BypassTransientForHint = Qt__WidgetAttribute(99)
|
|
Qt__WA_NativeWindow = Qt__WidgetAttribute(100)
|
|
Qt__WA_DontCreateNativeAncestors = Qt__WidgetAttribute(101)
|
|
Qt__WA_MacVariableSize = Qt__WidgetAttribute(102)
|
|
Qt__WA_DontShowOnScreen = Qt__WidgetAttribute(103)
|
|
Qt__WA_X11NetWmWindowTypeDesktop = Qt__WidgetAttribute(104)
|
|
Qt__WA_X11NetWmWindowTypeDock = Qt__WidgetAttribute(105)
|
|
Qt__WA_X11NetWmWindowTypeToolBar = Qt__WidgetAttribute(106)
|
|
Qt__WA_X11NetWmWindowTypeMenu = Qt__WidgetAttribute(107)
|
|
Qt__WA_X11NetWmWindowTypeUtility = Qt__WidgetAttribute(108)
|
|
Qt__WA_X11NetWmWindowTypeSplash = Qt__WidgetAttribute(109)
|
|
Qt__WA_X11NetWmWindowTypeDialog = Qt__WidgetAttribute(110)
|
|
Qt__WA_X11NetWmWindowTypeDropDownMenu = Qt__WidgetAttribute(111)
|
|
Qt__WA_X11NetWmWindowTypePopupMenu = Qt__WidgetAttribute(112)
|
|
Qt__WA_X11NetWmWindowTypeToolTip = Qt__WidgetAttribute(113)
|
|
Qt__WA_X11NetWmWindowTypeNotification = Qt__WidgetAttribute(114)
|
|
Qt__WA_X11NetWmWindowTypeCombo = Qt__WidgetAttribute(115)
|
|
Qt__WA_X11NetWmWindowTypeDND = Qt__WidgetAttribute(116)
|
|
Qt__WA_MacFrameworkScaled = Qt__WidgetAttribute(117)
|
|
Qt__WA_SetWindowModality = Qt__WidgetAttribute(118)
|
|
Qt__WA_WState_WindowOpacitySet = Qt__WidgetAttribute(119)
|
|
Qt__WA_TranslucentBackground = Qt__WidgetAttribute(120)
|
|
Qt__WA_AcceptTouchEvents = Qt__WidgetAttribute(121)
|
|
Qt__WA_WState_AcceptedTouchBeginEvent = Qt__WidgetAttribute(122)
|
|
Qt__WA_TouchPadAcceptSingleTouchEvents = Qt__WidgetAttribute(123)
|
|
Qt__WA_X11DoNotAcceptFocus = Qt__WidgetAttribute(126)
|
|
Qt__WA_MacNoShadow = Qt__WidgetAttribute(127)
|
|
Qt__WA_AlwaysStackOnTop = Qt__WidgetAttribute(128)
|
|
Qt__WA_AttributeCount = Qt__WidgetAttribute(129)
|
|
)
|
|
|
|
//Qt::WindowFrameSection
|
|
type Qt__WindowFrameSection int64
|
|
|
|
const (
|
|
Qt__NoSection = Qt__WindowFrameSection(0)
|
|
Qt__LeftSection = Qt__WindowFrameSection(1)
|
|
Qt__TopLeftSection = Qt__WindowFrameSection(2)
|
|
Qt__TopSection = Qt__WindowFrameSection(3)
|
|
Qt__TopRightSection = Qt__WindowFrameSection(4)
|
|
Qt__RightSection = Qt__WindowFrameSection(5)
|
|
Qt__BottomRightSection = Qt__WindowFrameSection(6)
|
|
Qt__BottomSection = Qt__WindowFrameSection(7)
|
|
Qt__BottomLeftSection = Qt__WindowFrameSection(8)
|
|
Qt__TitleBarArea = Qt__WindowFrameSection(9)
|
|
)
|
|
|
|
//Qt::WindowModality
|
|
type Qt__WindowModality int64
|
|
|
|
const (
|
|
Qt__NonModal = Qt__WindowModality(0)
|
|
Qt__WindowModal = Qt__WindowModality(1)
|
|
Qt__ApplicationModal = Qt__WindowModality(2)
|
|
)
|
|
|
|
//Qt::WindowState
|
|
type Qt__WindowState int64
|
|
|
|
const (
|
|
Qt__WindowNoState = Qt__WindowState(0x00000000)
|
|
Qt__WindowMinimized = Qt__WindowState(0x00000001)
|
|
Qt__WindowMaximized = Qt__WindowState(0x00000002)
|
|
Qt__WindowFullScreen = Qt__WindowState(0x00000004)
|
|
Qt__WindowActive = Qt__WindowState(0x00000008)
|
|
)
|
|
|
|
//Qt::WindowType
|
|
type Qt__WindowType int64
|
|
|
|
const (
|
|
Qt__Widget = Qt__WindowType(0x00000000)
|
|
Qt__Window = Qt__WindowType(0x00000001)
|
|
Qt__Dialog = Qt__WindowType(0x00000002 | Qt__Window)
|
|
Qt__Sheet = Qt__WindowType(0x00000004 | Qt__Window)
|
|
Qt__Drawer = Qt__WindowType(Qt__Sheet | Qt__Dialog)
|
|
Qt__Popup = Qt__WindowType(0x00000008 | Qt__Window)
|
|
Qt__Tool = Qt__WindowType(Qt__Popup | Qt__Dialog)
|
|
Qt__ToolTip = Qt__WindowType(Qt__Popup | Qt__Sheet)
|
|
Qt__SplashScreen = Qt__WindowType(Qt__ToolTip | Qt__Dialog)
|
|
Qt__Desktop = Qt__WindowType(0x00000010 | Qt__Window)
|
|
Qt__SubWindow = Qt__WindowType(0x00000012)
|
|
Qt__ForeignWindow = Qt__WindowType(0x00000020 | Qt__Window)
|
|
Qt__CoverWindow = Qt__WindowType(0x00000040 | Qt__Window)
|
|
Qt__WindowType_Mask = Qt__WindowType(0x000000ff)
|
|
Qt__MSWindowsFixedSizeDialogHint = Qt__WindowType(0x00000100)
|
|
Qt__MSWindowsOwnDC = Qt__WindowType(0x00000200)
|
|
Qt__BypassWindowManagerHint = Qt__WindowType(0x00000400)
|
|
Qt__X11BypassWindowManagerHint = Qt__WindowType(Qt__BypassWindowManagerHint)
|
|
Qt__FramelessWindowHint = Qt__WindowType(0x00000800)
|
|
Qt__WindowTitleHint = Qt__WindowType(0x00001000)
|
|
Qt__WindowSystemMenuHint = Qt__WindowType(0x00002000)
|
|
Qt__WindowMinimizeButtonHint = Qt__WindowType(0x00004000)
|
|
Qt__WindowMaximizeButtonHint = Qt__WindowType(0x00008000)
|
|
Qt__WindowMinMaxButtonsHint = Qt__WindowType(Qt__WindowMinimizeButtonHint | Qt__WindowMaximizeButtonHint)
|
|
Qt__WindowContextHelpButtonHint = Qt__WindowType(0x00010000)
|
|
Qt__WindowShadeButtonHint = Qt__WindowType(0x00020000)
|
|
Qt__WindowStaysOnTopHint = Qt__WindowType(0x00040000)
|
|
Qt__WindowTransparentForInput = Qt__WindowType(0x00080000)
|
|
Qt__WindowOverridesSystemGestures = Qt__WindowType(0x00100000)
|
|
Qt__WindowDoesNotAcceptFocus = Qt__WindowType(0x00200000)
|
|
Qt__MaximizeUsingFullscreenGeometryHint = Qt__WindowType(0x00400000)
|
|
Qt__CustomizeWindowHint = Qt__WindowType(0x02000000)
|
|
Qt__WindowStaysOnBottomHint = Qt__WindowType(0x04000000)
|
|
Qt__WindowCloseButtonHint = Qt__WindowType(0x08000000)
|
|
Qt__MacWindowToolBarButtonHint = Qt__WindowType(0x10000000)
|
|
Qt__BypassGraphicsProxyWidget = Qt__WindowType(0x20000000)
|
|
Qt__NoDropShadowWindowHint = Qt__WindowType(0x40000000)
|
|
Qt__WindowFullscreenButtonHint = Qt__WindowType(0x80000000)
|
|
Qt__WindowOkButtonHint = Qt__WindowType(0x00080000)
|
|
Qt__WindowCancelButtonHint = Qt__WindowType(0x00100000)
|
|
)
|
|
|
|
type Qt struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type Qt_ITF interface {
|
|
Qt_PTR() *Qt
|
|
}
|
|
|
|
func (p *Qt) Qt_PTR() *Qt {
|
|
return p
|
|
}
|
|
|
|
func (p *Qt) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *Qt) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQt(ptr Qt_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.Qt_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQtFromPointer(ptr unsafe.Pointer) *Qt {
|
|
var n = new(Qt)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQtFromPointer(ptr unsafe.Pointer) *Qt {
|
|
var n = NewQtFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QtGlobalStatic::GuardValues
|
|
type QtGlobalStatic__GuardValues int64
|
|
|
|
const (
|
|
QtGlobalStatic__Destroyed = QtGlobalStatic__GuardValues(-2)
|
|
QtGlobalStatic__Initialized = QtGlobalStatic__GuardValues(-1)
|
|
QtGlobalStatic__Uninitialized = QtGlobalStatic__GuardValues(0)
|
|
QtGlobalStatic__Initializing = QtGlobalStatic__GuardValues(1)
|
|
)
|
|
|
|
type QtGlobalStatic struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QtGlobalStatic_ITF interface {
|
|
QtGlobalStatic_PTR() *QtGlobalStatic
|
|
}
|
|
|
|
func (p *QtGlobalStatic) QtGlobalStatic_PTR() *QtGlobalStatic {
|
|
return p
|
|
}
|
|
|
|
func (p *QtGlobalStatic) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QtGlobalStatic) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQtGlobalStatic(ptr QtGlobalStatic_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QtGlobalStatic_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQtGlobalStaticFromPointer(ptr unsafe.Pointer) *QtGlobalStatic {
|
|
var n = new(QtGlobalStatic)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQtGlobalStaticFromPointer(ptr unsafe.Pointer) *QtGlobalStatic {
|
|
var n = NewQtGlobalStaticFromPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//QtMetaTypePrivate::IteratorCapability
|
|
type QtMetaTypePrivate__IteratorCapability int64
|
|
|
|
const (
|
|
QtMetaTypePrivate__ForwardCapability = QtMetaTypePrivate__IteratorCapability(1)
|
|
QtMetaTypePrivate__BiDirectionalCapability = QtMetaTypePrivate__IteratorCapability(2)
|
|
QtMetaTypePrivate__RandomAccessCapability = QtMetaTypePrivate__IteratorCapability(4)
|
|
)
|
|
|
|
type QtMetaTypePrivate struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QtMetaTypePrivate_ITF interface {
|
|
QtMetaTypePrivate_PTR() *QtMetaTypePrivate
|
|
}
|
|
|
|
func (p *QtMetaTypePrivate) QtMetaTypePrivate_PTR() *QtMetaTypePrivate {
|
|
return p
|
|
}
|
|
|
|
func (p *QtMetaTypePrivate) Pointer() unsafe.Pointer {
|
|
if p != nil {
|
|
return p.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *QtMetaTypePrivate) SetPointer(ptr unsafe.Pointer) {
|
|
if p != nil {
|
|
p.ptr = ptr
|
|
}
|
|
}
|
|
|
|
func PointerFromQtMetaTypePrivate(ptr QtMetaTypePrivate_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QtMetaTypePrivate_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQtMetaTypePrivateFromPointer(ptr unsafe.Pointer) *QtMetaTypePrivate {
|
|
var n = new(QtMetaTypePrivate)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func newQtMetaTypePrivateFromPointer(ptr unsafe.Pointer) *QtMetaTypePrivate {
|
|
var n = NewQtMetaTypePrivateFromPointer(ptr)
|
|
return n
|
|
}
|